From 3d40f4decf2af83a7615320864a1b95f0658cab3 Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Fri, 5 Oct 2018 16:07:50 +0200
Subject: [PATCH 1/6] Updating gradient descent methods

---
 doc/pub/NeuralNet/ipynb/NeuralNet.ipynb | 781 +++++++++++++++++++++---
 doc/src/Splines/Splines.do.txt          |  14 +-
 2 files changed, 693 insertions(+), 102 deletions(-)

diff --git a/doc/pub/NeuralNet/ipynb/NeuralNet.ipynb b/doc/pub/NeuralNet/ipynb/NeuralNet.ipynb
index 6d7b7115e..b66a2a5e6 100644
--- a/doc/pub/NeuralNet/ipynb/NeuralNet.ipynb
+++ b/doc/pub/NeuralNet/ipynb/NeuralNet.ipynb
@@ -597,9 +597,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -1520,10 +1518,28 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "inputs = (n_inputs, pixel_width, pixel_height) = (1797, 8, 8)\n",
+      "labels = (n_inputs) = (1797,)\n",
+      "X = (n_inputs, n_features) = (1797, 64)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# import necessary packages\n",
     "import numpy as np\n",
@@ -1589,10 +1605,17 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training images: 1437\n",
+      "Number of test images: 360\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.model_selection import train_test_split\n",
     "\n",
@@ -1712,10 +1735,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 5,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# building our neural network\n",
@@ -1791,11 +1812,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probabilities = (n_inputs, n_categories) = (1437, 10)\n",
+      "probability that image 0 is in category 0,1,2,...,9 = \n",
+      "[3.89940599e-05 1.79115580e-01 1.47286800e-02 7.96733555e-01\n",
+      " 3.28982767e-04 1.49752254e-07 9.19699482e-05 4.42365585e-03\n",
+      " 3.57722690e-06 4.53485505e-03]\n",
+      "probabilities sum up to: 1.0000000000000002\n",
+      "\n",
+      "predictions = (n_inputs) = (1437,)\n",
+      "prediction for image 0: 3\n",
+      "correct label for image 0: 6\n"
+     ]
+    }
+   ],
    "source": [
     "# setup the feed-forward pass, subscript h = hidden layer\n",
     "\n",
@@ -1991,11 +2027,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Old accuracy on training data: 0.16423103688239388\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  after removing the cwd from sys.path.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "New accuracy on training data: 0.10090466249130133\n"
+     ]
+    }
+   ],
    "source": [
     "# to categorical turns our integer vector into a onehot representation\n",
     "#from keras.utils import to_categorical\n",
@@ -2095,10 +2152,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "class NeuralNetwork:\n",
@@ -2220,11 +2275,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy score on test set:  0.9305555555555556\n"
+     ]
+    }
+   ],
    "source": [
     "epochs = 100\n",
     "batch_size = 100\n",
@@ -2256,11 +2317,240 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.18888888888888888\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.18333333333333332\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.20277777777777778\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.2\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.12222222222222222\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.18888888888888888\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.1527777777777778\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.5916666666666667\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.5583333333333333\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.5361111111111111\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.5777777777777777\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.6055555555555555\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.6416666666666667\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.8111111111111111\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.8833333333333333\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.8666666666666667\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.875\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.8666666666666667\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9416666666666667\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.9416666666666667\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9472222222222222\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9333333333333333\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9416666666666667\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9361111111111111\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9527777777777777\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9333333333333333\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.23055555555555557\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  after removing the cwd from sys.path.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.11666666666666667\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.08611111111111111\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.125\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:44: RuntimeWarning: overflow encountered in exp\n",
+      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:45: RuntimeWarning: invalid value encountered in true_divide\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "eta_vals = np.logspace(-5, 1, 7)\n",
     "lmbd_vals = np.logspace(-5, 1, 7)\n",
@@ -2293,11 +2583,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  after removing the cwd from sys.path.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# visual representation of grid search\n",
     "# uses seaborn heatmap, you can also do this with matplotlib imshow\n",
@@ -2355,11 +2672,220 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.7/site-packages/sklearn/neural_network/multilayer_perceptron.py:564: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  % self.max_iter, ConvergenceWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.20833333333333334\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.16944444444444445\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.18055555555555555\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.17222222222222222\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.23333333333333334\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.2916666666666667\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.1527777777777778\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.8666666666666667\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.8416666666666667\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9277777777777778\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.8861111111111111\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.8805555555555555\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.875\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.875\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9833333333333333\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9833333333333333\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9805555555555555\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9805555555555555\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9805555555555555\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.9527777777777777\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9916666666666667\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9833333333333333\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9944444444444445\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.975\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.9416666666666667\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9416666666666667\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.75\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.8972222222222223\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.8944444444444445\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9277777777777778\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.8972222222222223\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.7388888888888889\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.08611111111111111\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.11388888888888889\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.1527777777777778\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.15\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.08888888888888889\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.15\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.1\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.11944444444444445\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.18055555555555555\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.08333333333333333\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.09166666666666666\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.08055555555555556\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.neural_network import MLPClassifier\n",
     "# store models for later use\n",
@@ -2388,11 +2914,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAJgCAYAAABmwww9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XmcjeX/x/HXfc6ZGbMY6wzDIJWlQsoSWYqSNSK+kVREK1lKq1b5UWT5JqFQiFDW9EUoKkt7JEubkGWMMYZZzzn3/fvjaMZtSTFzjjPn/Xw85sF9n+vc9/U59zX3ue7Pdd33GJZlWYiIiIiEIEegKyAiIiISKOoIiYiISMhSR0hERERCljpCIiIiErLUERIREZGQpY6QiIiIhCx1hET86KWXXqJDhw506NCBGjVq0LJly9zlrKysf7ydVatW8dJLL/1tmQMHDtC1a9fzrfIpRowYQY0aNdi/f3++b1tExN8MPUdIJDCaN2/OuHHjqFmzZqCr8o9lZ2dz3XXX0ahRIxISEnj00UcDXSURkfOijJDIBaRGjRr079+fli1bsnnzZt5//326dOnCLbfcQrNmzZg1axYA8+fP57777gOgR48evPrqq3Tv3p3mzZszePBgTNNkz549XHXVVQC89tprPPHEE9xzzz20atWK22+/nQMHDgCwadMmOnXqxM0338xDDz1Ex44d2bhx42nrt3TpUipWrMjdd9/N3LlzyczMzH3t999/p0ePHrRt25abb76Zjz766G/XN2/enM2bN+e+/6/lPXv2cN1119GrVy9atmxJUlISEydOpHPnztx8883ceOONfPzxxwB4PB6GDx9Oy5YtadOmDU8//TQ5OTm0bNmSzz//PHfbQ4YM4Z133smXYyQihYs6QiIXELfbTbNmzVi+fDkXX3wx8+bNY/LkySxcuJAxY8YwcuTI075v165dzJgxg8WLF7Nhwwa+/PLLU8p8/fXXjBs3jmXLlhEbG8ucOXPweDz069eP/v37s2TJEnr06MHWrVvPWL/Zs2fTvn17atasSVxcHAsWLMh9bdCgQbRq1YqlS5cyefJkRo8ezbFjx864/u/s37+fBx98kOXLl+N2u1m3bh0zZ85kyZIlDBw4kP/+978AzJo1iy1btrBo0SI+/PBD0tPT+eijj+jWrRvz5s0D4NixY6xatYqOHTue9fMXkdDjCnQFRMSubt26AERHRzNx4kTWrFnDzp072bZtGxkZGad9T7NmzXA4HMTExFCpUiWOHDlCYmKirUz9+vWJiYkB4PLLL+fIkSPs2LEDgOuuuw6ABg0aUKVKldPuY8uWLWzdupXJkycDcMsttzB9+nS6devGkSNH2LZtG126dAEgISGBlStXkpqaetr1Z+NyuahduzYA5cuX5+WXX2bJkiX88ccf/PDDD6SnpwOwbt06OnToQJEiRQAYO3YsAGlpabz++uukpKSwbNkyrr/+emJjY8+6XxEJPcoIiVxgoqKiAF9W5JZbbuHPP/+kTp06DBgw4Izv+asjAGAYBqeb+ne6Mk6n85SyTqfztPuYNWsWLpeLW2+9lebNmzNjxgx27tzJ2rVrcblcudv9y2+//Za7rZPX/zUx/MR95+Tk5P4/PDw8d5tbtmyha9euHDt2jEaNGtG7d+/ccn+V+UtycjJJSUnExsbSqlUrFi9ezAcffEC3bt1OG5OIiDpCIheoH3/8kZIlS/Lggw/SpEkTPvnkEwC8Xm++7eOSSy4hPDyctWvXAr75Qjt27LB1XMCXYVm6dCkTJ05k9erVrF69mrVr19K+fXvefvttYmJiuOKKK1i4cCEA+/bto1u3bmRlZZ12/dGjRylZsiQ//vgjAN9//z0HDx48bR2/+uoratSoQc+ePalfvz6rVq3K/QwaNmzIhx9+SE5ODqZp8vzzz7N06VIAunfvzvTp07Esi1q1auXbZyYihYuGxkQuUI0aNeL999+nVatWREZGUqtWLUqWLMkff/yRb/twuVy89tprPPfcc4wePZqLLrqI0qVL27JHAAsWLOCSSy6hQYMGtvUPPPAAbdu2ZceOHbz66qu88MILzJgxA8MwGDZsGHFxcWdc/+ijj/L8888zZ84crrjiCq644orT1rFdu3asWLGCNm3aEBYWRsOGDTly5AjHjh2ja9eu/Pnnn3Tq1AnLsqhfvz49evQAoHr16hQrVqxAHiEgIoWHbp8XCXEvv/wy99xzD6VLl2bfvn106NCBlStXBv2cml27dtGjRw+WLVtGZGRkoKsjIhcoZYREQlz58uW5++67cblcWJbFSy+9FPSdoHHjxjF37lyefvppdYJE5G8pIyQiIiJB469h8YkTJ55yd+zWrVsZMmQIx44do27durzwwgun3FRxMk2WFhERkaDwww8/0K1bN3bu3Hna1wcPHswzzzzD8uXLsSyLuXPnnnWb6giJiIhIUJg7dy7PPfcc8fHxp7z2559/kpWVlfsMsk6dOrFs2bKzblNzhERERCRg0tLSSEtLO2V9bGzsKfMVhw0bdsbtJCUlERcXl7scFxeX+6eE/k5QdoRaX/5UoKsQMNZJz3cJNYZpBroKgeUN3fityPBAVyGgUmsUD3QVAqrEmvx7bEQw+t+e//p1f+b+qn7b1zvz+jF+/PhT1vft25d+/fr94+2cbsrzyc9EO52g7AiJiIhI4XDXXXed9m8B/tu7V8uUKUNycnLu8sGDB087hHYydYRERETExsR/2efTDYGdi/LlyxMREcE333xDnTp1WLhwIU2bNj3r+zRZWkRERIJWnz592Lx5MwCjRo1i+PDhtG7dmszMTO68886zvj8onyOkOUKhS3OEQjd+zRHSHKFQ5u85Qtn7LvbbviISfvPbvk5HGSEREREJWeoIiYiISMjSZGkRERGxMQm6WTPnTBkhERERCVnKCImIiIiNP2+fDzRlhERERCRkKSMkIiIiNt7ge7LOOVNGSEREREKWMkIiIiJio7vGREREREKAMkIiIiJi41VGSERERKTwU0ZIREREbDRHSERERCQEKCMkIiIiNnqOkIiIiEgIUEZIREREbELnL40pIyQiIiIhTB0hERERCVkaGhMREREbPVBRREREJAQoIyQiIiI23tBJCCkjJCIiIqFLGSERERGx0e3zIiIiIiFAGSERERGx8WIEugp+o4yQiIiIhCxlhERERMTG1F1jIiIiIoWfMkJnUK9pNXoOvImwcBe/79jP2CHzyUjPtpVpdnNtOvdsgoVFdqabif/3IT9v+TNANc4/9ZtWo+eAmwgLd/L7jv2MeWbBKbE3b3clnXs1wbIgOzOHN4YvLRSxA9S7rho9B7b0Hfvt+xk75IPTH/teTbEsi+wsNxOHLQnq+OtdX52eg1odj3kfY596/5SY/zJoRBf+2HGAD6auBSCmWCR9X+jIJdXLkZWZw8fzv2bxjHX+rP55qd+kKj0fbpH7uz7m+YWntve2V9L5rsa5x/uNl5fy8097MQyDXv1bUL9pNUzTYu+uQ/x36CKOHM4IUDT/3rW1K/PgbU0Iczn5ZfdBhr25gozMHFuZzi1q0+nGK7Es+DMpleFvreBwWiYA/3vjAQ4ePpZb9t0Pv2L5um1+jeF81Gt+OT2fvNl3/LfuZeyjs8k4lnXasoNGd+eP7fv4YNLq3HVt72xMq24NCS8Sxi+bdzP20dm4czz+qn6B0RyhEFesRDSDht3KSwNm0aftGPbvTqHnoJa2MuUvKk3vR1sx5N636dtpPO9N+oQh/+0eoBrnn2Ilohj0UieGDphF73Zj2bfn8CmxJ15Umt6PtmbIve/w0K3jmT3pU54Zd3uAapy/fMe+My/1f5c+bUazf08KPR9pZStT/qLS9B7cmiH3TqNvp9d4b+InDPnvHQGq8fkrViKaQcO78FK/GfRpNcrX3h9tfUq5CpfEM/ydPjRpXcu2/r6nbiYrPYf72rzKwP+8Tt2m1ah/fXV/Vf+8FCsRxaAXOzL0kdn07jCOfX8epmf/FrYyiZVK03tgS4Y8+A4P3TaB2W9+yjOjuwHQ8parufTycvS9bQIPdB7P3l2H6PPIqZ/dhap40UiG3NuKJ8cu5rbB09ibdISHbmtiK1Ptoni6t61Ln+dn0/2Jd9i9P5V7OzcCoGJCCY6mZ3HnUzNyf4KpE1SsZAyDRnfnpXun0ue6YezfdYieT958SrkKl5Zh+Jy+NLn5Ktv6a1vXon3PpjzZ7XXubz6c8CJh3NLnej/VXvKL3zpCv/76KxMmTODZZ5/l+eefZ8KECWzevNlfu/9Xrm50KTt+3MPePw4B8OF7G2nWrratjDvHw9hnFnA4+SgAO378kxKlY3CFOf1e3/x09bVV2PHjn+zd5Yt96Xsbad72SlsZd46Hsc8uIOWv2LcUjtgBrm5UxX7sZ284w7Gfz+GDfx37PUEd/9WNq7Bj8257zO2vOqVcu+4N+Xj+13z2v0229ZdeUZ5Vi77FNC08bi9ffrqNxq1q+qXu5+vqhpceb+8pACyd+yXN25zU3t0exr6wkJRkX9Zjx097fcfb5eSPX5OYMno5brc397X4hGL+DeI8XFOzElt/28/uA6kAzF/5Ay0bXWYrs31nEp0fmUp6Zg7hYU7iSsRw5HjGpGaVcpimxetPd2Hm8Dvp1bEBDiN4MglXX1edHT/sYu/vBwH4cPrnNOtY95Ry7e5uwsdzN/LZku9s62+4tT7zJ3/CsdQMLMti/BNzWf3BV36pe0HzYvjtJ9D8MjT27rvvMnfuXFq2bEnNmr4T5MGDB3nmmWdo3749vXr18kc1/rHSZYtxcP+R3OXkA2lEFy1CVHREbso8aW8qSXtTc8vc+3gbNq7ehuf4CTFYxSXYYz94mtgP7E3lwAmx3/dYGzZ8Evyxw/Fjv+/fHvu2bPxka9DGXzqhuD3m/UdOiRngjRcXAVC74aW292//YTc3dLian77dSVi4i0Y31cDrCY7HscWVLcbBA/+yvT/amg2fbsfj8bJ10+7c9TFFi9D9vutZOi94vgjjS8VyIOVo7nJSylFioiKIigy3DY95vSZN61zKU31uIsft4c33vwDA5XTw5Y9/8NqstUSEuxg9uCPpmTnMWfat32M5F6XLFefg3sO5y8n7UomOjSQqpohteOyNIe8DULtRVdv7Ey+OZ8f3fzB05gOUKhPLjxt/Y8qwRf6pvOQbv3SEpk+fzsKFC4mMjLSt79mzJx07drzgOkIOx+l7qF7z1JN7RGQYj/xfZ+LKFmPIvW8XcM0KnnGGq7kzxf7osFspXbYYQ+57p6Cr5hf//th3IS6hGEP6TCvoqhWYfxPz6bw54kN6P9GW8Qv7k3LwKN+t+5nLr6qUn1UsMP+6vb/YydfeH5xuey0hsQTPju3Olu/+YMl7GwukrgXhDIce8zTxr/3mF9Z+8wsdmtVk7BO30nnQFBZ9kpfVd3u8zP7oG7q0vCpoOkJnyl55vf+s7TvDHFzVtDov9nqTnGw3j4y5g7sfb8ek5+fnZzUDwrQCn6nxF78MjblcLjyeUyePZWVlERYW5o8q/CtJ+45QMq5o7nLpMrEcPZJBdqbbVi4uoRij370f02vx+N1vkX709BPsgsnBfan22OPPHPuYd+/D67V4vOeUQhE7QNLJ8ZeJ5WjqGY79rAcwTZPH73ozqONP2vvPYj6TqJgiTHnlIx5oN4ane76FZVq5w2wXuoP7j1Cy9Intvejp23vZYox55168psXjvafajnetepUZM+NeVi7+jtdeWuK3uueHA4eOUrp4dO5yXMkYjhzLJCs773ydWKY4V1Ytn7u85NMfKVs6lqLRRWjV+DIurVA6b4PGP+9EXAiS9h6mZHzeUGbpssU4mppO9kmTxc8k5UAa65b9QMaxLDxuL6vnf0X1OhcVUG2loPilI3T//fdzyy23MGTIEMaNG8e4ceMYMmQIXbp04f777/dHFf6Vb7/4meq1KlKuUikA2txWn/Wrt9rKxBSL5JV3+vDFyi2MePQ9crKD/y4BgG/W/UL1WhUoV9EXe9szxD7y7d588fFPjBg8p9DEDseP/ZUVTjj217B+9U+2MjHFInll+r188fEWRjwS/Mf+2893UL32Ce29WwPWr/rpLO/K06bbNfTofxMAxUvF0Oo/9fn0w+8LpK757Zv1f7X3kgC07VKf9Z/aJ/vGxEYycuo9fLHqJ0Y8Ptd2vC+7sgLPju7GyKc/4IPpX/i17vlh4+ad1Lg0gQpligPQ8YYr+eybX21lShWPZmi/thSL8WX0Wza6jN92J5N2LItLEkvTp3MjHIZBRJiLLi2uYuWG7X6P41x9u2Yb1a+uRLnKcQC06dGY9cv/+dzVz5d+T5O2VxFexHdB37BVLXb8sKtA6ioFx7Asyy+PTTpw4ADr168nKSkJy7IoU6YMDRs2pEyZMv96W60vf6oAamhXr2lV7h7QEleYk327Uxj15DwSEkvSf2hH+nYaT9f7rueOvjey8+f9tvc92XMKR49kFli9LD9MRKzXpCo9B96Ey+WLfeRT75OQWJIBL3bkoVvH0/Xe6+nR9wZ2/nzA9r4nehVs7ADGPxyuOR/1mlbj7oEnHPsn5h4/9p3o2+k137Hv14KdO0469r2mcDS1gG+bLqCr7XrXVePuR1rhCnOxb9chRj02h4QKJek/rDN9O4yzlT359vnI6HAeHdmVchVLYRgGcyZ9wieLvzvdbs6LFRme79sEqNe4Cj0fvsl3vPekMPLpD0hILMGA527hodsm0LX3dfR4sPmp7f3eaTz58n+oViOR/X/mzTPZv/cwQwfOzvd6ptYonu/bBGh4ZWUevK0xYS4ne5JSefGNZZSLL8ZTfW7izqdmANDphiu5tUVtvKZJ8uFjjHx7FfsOphER7uLRu26gRpUEXE4HqzbuYOLczwukniXW/FEg263X/HLufuJm3/H/I5lRA2aSULEU/Ud2o2/LV2xlT7593uEw6Nq/JdfdfDUOp8Evm/fw2hNzznj7/fn4357/5vs2/863uyr6bV9XVwxs59FvHaH85I+O0IXKHx2hC5k/OkIXtCAadshvBdURChYF1REKFgXVEQoW6ggVHD1QUURERGy8IfSYwdCJVEREROQkygiJiIiIjW6fFxEREQkBygiJiIiIzYXwpy/8RRkhERERCVnKCImIiIiN1wqdPEnoRCoiIiJyEmWERERExMYMoTxJ6EQqIiIichJlhERERMRGd42JiIiIhABlhERERMRGd42JiIiIhAB1hERERCRkaWhMREREbExNlhYREREp/JQREhERERtvCOVJQidSERERkZMoIyQiIiI2un1eREREJAQoIyQiIiI2+qOrIiIiIiFAGSERERGx8Vp6jpCIiIhIoaeMkIiIiNjoOUIiIiIiIUAZIREREbEx9RwhERERkcJPGSERERGx0RwhERERkRCgjpCIiIiELA2NiYiIiI0eqCgiIiISAoIyI9RryfJAVyFgijsyAl2FgCrlTA90FQJqvzc20FUImDC8ga5CQLlxBroKAZVuRgS6CiFFf3RVREREJAQEZUZIRERECo5XD1QUERERKfyUERIREREbE901JiIiIlLoKSMkIiIiNpojJCIiIhIClBESERERG/3RVREREZEQoIyQiIiI2Jj6W2MiIiIihZ8yQiIiImKjOUIiIiIiIUAdIREREQlZGhoTERERG1MPVBQREREp/JQREhERERuv/uiqiIiISOGnjJCIiIjYaI6QiIiISAhQRkhERERsNEdIREREJAQoIyQiIiI2miMkIiIiEgKUERIREREbrzJCIiIiIoWfMkIiIiJiY+quMREREZHCTxkhERERsdEcIREREZEQoIyQiIiI2JiW5giJiIiIFHrqCImIiEjI0tCYiIiI2HhDKE+ijtBx27/0sOLtHLxuizKVHXQcUIQiUfYx0p/WeVg1MwfDAZExBrf0j6BUggPTa/HhG9n8vtkLQNV6LlrdE45hBM8Y648bLRZPs/C4oXxluH2gQWS0vf6fLrJYu9giLALKVoD/9DWILppX5vBBi1EDLJ6cYBBTLHhiB/h2o4P3poThcUPFyhb3PpJDVLS9zLKFTlYschEeDuUqmvTq5yYmFjLSYdKr4ezdbWCZ0LSFl/ZdPYEJJB9s2WiydJoXjxvKVTboOtBJkZPawtpFXj5fbBIWAWUqGNza12lrC8Em1Nv/iULt+J/PuT/jqMXi8dns/81LWBGDq1u4aNg+PECRyLkKnS7f30g/YjF/TDbdni7CgDejKVnWwYpp2bYy7myLeSOzuH1IEfqOj6L6NU6WTvSV+X61h4N7LPpNiKLv61Hs3Oxly+feQIRyTo6mWswcbdH7GYNnpzgolQCLp1m2Mjt+sFg5z6LfCIMnJzi4op7B7HF5ZTautBjziMWRQ/6u/flLS4VJo8IZ+GwOo6dlE59gMntKmK3Mlu8dLJkTxtOvZDNiUjZX1Td5c6zvhDf37TBKlrYY+WY2L43P5uMPnez4KTh/tY6lWrw32kvPZ1w8NSWMUgkGH04zbWV+/sFk9TyTB0e4GDwhjMvqOZg7Lnja+8lCvf2fKNSO//me+z+anE14JDw8MYr7Rkfy89detm0M3ougE5mW4befQAvOs3U++/lbD+WrOihd3vdx1G8bxg+feLCsvBOdefxckJXuW5eTCa6wvNfcWb6rSY8bvB5wBdFFwbZvoVJViC/va5BN2hp8tRpb/Lt+hmq1oUScr8yVjeHHjeBxW6Qesti0zuKBoYFv0Odi0zdOLq5qkpDoi7fFzV6+WOXkhPD5/WcHNa7yUirOt1yvsZdvNzjwuOGuB93ccZ8bgNQUA4/bICraOnk3QWH7txYVqhrEHW8Ljdo6+Ga1aWsLe362qFrboPjxtlCrscGWjRYed3DGHOrt/0ShdvzP99y/9xeT2s1dOJwGrjCDqvWcbPmicHSEQomGxoAjBy2Klc47icWWNsjOgOxMKBLlWxcRadC+bwSTH8kkKtbANOHeUZEAXH2jiy2fe3jlznRML1x6lZPq1wTPR3v4IBSPy1suHgdZGb6fyOPDQxdVgzWLIOWARckyBhtW+Dp96WlQvJRBn2f/+vyC72R46KBBqbi8epeMs8jMMMjMIHd47JJqJssWhHHwgEFcGYs1y5143AZH06BEKXA6YfyIML5c66RuIy/lEoPvcwDf8M5fX3AAxY63hewMKHL8s6hYzWDtIjO3LXy5wsR7vC0UKxWgip+HUG//Jwq143++5/7Eag6+X+2h0uVOPG7Y8oUXZ/Cc+v+WGUJ5Er8csr179/7t6+XKlfNHNc7IOsO5y3FCO9j/u5dPZuXw8KQoSiU4WL8oh9nDsnhofCSrZ+UQFWvwxLvReHLg3aFZfD4/h8adgiMtdMb4nXn/v7SmQevuMPlFC8Nh0fAmg6ii4Aw7/XuDiWWefv2Jx/+yWia39vAw+vlwDAOub+UhpqiVe2UI0PcJN1n93Yx5IZwPZrroclfwXRmeqS0YJ7SFS2o6aNkdpr7owXAYXHO8LbiCtC2Eevs/Uagd//M997fuHcGyt7J5vV8mRUsYXHqVk11bg3OYMFgsWbKEN954A7fbzd1330337t1tr2/ZsoVnn30Wt9tNQkICI0eOJDY29m+36ZeO0H333cfOnTuJj4+3pRwBDMNg1apV/qjGGRWPM9izPa9eackWkTEQXiTvSuGXb71UvNxJqQTfb8g17cL46M0cMtLgp3Ve2t0fjivMwBUGV93gyxA17uT3UM5JiTjYuS1v+UgyRMVAxAnxZ2VYVKkF17byxZ922OLD6RBd1N+1zX+l4i1+2ZZ35ktJNogualEkMq9MZoavM9SstW9uQOphmPd2GDFF4YevHFSobFKyNBSJhGubefnyc+fJuwkKJeIMdm3L6xmeqS1cUsugQSvfN9/Rwxb/m24SFaRtIdTb/4lC7fif77nfnW3R8p4Ioo5PFF87L4dS5QpHJsV7AczdOdmBAwcYM2YM8+fPJzw8nK5du3LNNddw6aWX5pYZNmwYDz/8MNdddx0jRoxgypQpDBw48G+365cjNnv2bCpXrswrr7zC6tWrbT+B7gQBXHq1k93bTJL/9J0AvvrITfUG9j5iwiUOdm72cuywr8zW9V5KlDGILmZQ7hIHP37mu/r3eiy2bfSQWD14vggvq+P7Ikj603dC+GypRc2G9jJHDsG4xywyj4+TL5tlUfd6gurOuDOpVcfLz1sd7Nvji2Xlh07qNrRf1R0+ZDD00Qgy0n3LC2aGcW0zL4YBG9Y6mT8zDMsCdw5sWOPkitrBeVVYrY7Bzm0WB4+3hXVLTWo0tB/jtEPw+mOe3DkTK2aZXH29I2jbQqi3/xOF2vE/33P/lx+5WTUjB4Bjh02+Xuam1vWFZGzsArRu3ToaNGhA8eLFiYqKomXLlixbtsxWxjRN0tN9J+rMzEyKFCly1u0a1skpmgKyadMm5s2bx9ChQ897W/N+rZMPNbLb/pWHj9/OweuxKFnWwa2PFuHwPpMF/82m73jfYPGGJTls/NCN02UQWdSg3QPhlKnkJCPNd/v83l+9OBwGF9d20rp3OE5X/p8Yijsy8n2bAFu+PH77sAdKJ8Cdgw2S98GssRZPTvD1l9cstli7xMIy4ZIroMtDBuER9hj7tjIZMafgbh8u5UwvkO1+t9HBe1N9t8+XKWfx4GM5HNhn8ObocEZM8mWBli90smKxC8uCajVMevZ1Ex4B6cdgyrgwdu90YAB1G3npfKfHll7PL/u9f5/izQ8/fXn89mkPlE4wuH2wk0P7LOaM9TJ4gi8L8NliL58vMbFMuPgKg04POU9pC/ktjILrXAZD+3fjn4urC/X4p5sRBbLd8zn3Z2dYvD8qi0P7LLCg6X/CqN28YMYIu1zyTYFs90z6f9fNb/saeskk0tLSTlkfGxtrG9aaNGkSGRkZuRmeefPmsWnTJlu/4vvvv6dnz55ER0cTGRnJ3LlzKVGixN/u328dofxUEB2hYFFQHaFgUVAdoWDhj47QhaogO0LBwF8doQtVQXWEgkVh7ghd+vm1jB8//pT1ffv2pV+/frnLEydOJDMz09YR2rx5My+++CIAWVlZ3HrrrQwfPpxatWoxbdo01q9fz+TJk/92/8rhiYjkm1dbAAAgAElEQVSIiI1p+W+u01133UXHjh1PWX/yJOcyZcrw9ddf5y4nJSURHx+fu7xjxw4iIiKoVasWALfddhvjxo076/4Lx6wuERERCUqxsbEkJiae8nNyR+jaa69l/fr1pKSkkJmZyYoVK2jatGnu65UqVWL//v389ttvAKxatYqaNWuedf/KCImIiIiNlwtv8nuZMmUYOHAgd955J263m86dO1OrVi369OnDww8/TM2aNRk+fDgDBgzAsixKlSrF//3f/511u5ojFGQ0R0hzhEKV5ghpjlAo8/ccoQe/vcNv+5pw9Uy/7et0lBESERERmwvhb4D5i+YIiYiISMhSR0hERERClobGRERExMaft88HWuhEKiIiInISZYRERETExrwAb58vKMoIiYiISMhSRkhERERsvLp9XkRERKTwU0ZIREREbHTXmIiIiEgIUEZIREREbPQnNkRERERCgDJCIiIiYqPnCImIiIiEAGWERERExEZzhERERERCgDJCIiIiYqPnCImIiIiEAHWEREREJGRpaExERERsNFlaREREJAQoIyQiIiI2eqCiiIiISAhQRkhERERsNEdIREREJAQoIyQiIiI2ygiJiIiIhABlhERERMRGGSERERGREBCUGaFbo48GugoBY2IGugoB5aBIoKsQYDmBrkDAhHrb91rZga5CQCWZhwJdhZCijJCIiIhICAjKjJCIiIgUHD1ZWkRERCQEKCMkIiIiNpojJCIiIhIC1BESERGRkKWhMREREbHR0JiIiIhICFBGSERERGyUERIREREJAcoIiYiIiI0yQiIiIiIhQBkhERERsbGUERIREREp/JQREhERERv90VURERGREKCMkIiIiNjorjERERGREKCMkIiIiNjorjERERGREKCMkIiIiNhojpCIiIhICFBHSEREREKWhsZERETERpOlRUREREKAMkIiIiJio8nSIiIiIiFAGSERERGxsaxA18B/lBESERGRkKWMkIiIiNiYaI6QiIiISKGnjJCIiIjY6DlCIiIiIiFAGaF/ybLgqRFQpTL06hro2viXZcHTIwyqVIaeXUPoloLjQvnYQ+GOf816GDvZQY4bql4MQx83iYm2l3n3A4NZCwwiIuDiihZDBloUj4XUNBg62mDbLwaRRaBja4vutwbP78fa9Qbj3nQej93ihce8p8Q+a76D2QscFAmHypUsnh7gpVgsHEmDl8Y4c2O/pbXJ7Z3MwARyjjZscDHlrQjcOXDxxSaPDM4k+qT4F8wPY9HCcCIioGJFk379M4mN9b22aFEY/1saTk4OVKnq5ZFHswgP938c+U3PEZLT+nUn9BwIyz4JdE3879ed0Gugg+WfhM4vx4lC+dhD4Y4/JRWGjHAwdqjJ0pkmieUsRk+yt/ON38KU2QZTRpvMn2LStAE8P8p3+nx5vEFUJCx+x2TWGyafbTT4dF0gIvn3UlLhmZedjH7Rw5IZHhLLWYydbP9a+PI7g6mzHLz5qod5Uzw0aWDywignAK+87iQqEha+7eHdCR4+32iwZl3wnCNSUw1GvVKE557P5O3p6SSUM3nrzSK2Mt9/52TOexGMfDWDSW+mU/8aD2NGRwLw2VoXixaE88qodN6amk52tsEH7xeCXlCI8VtHaOXKlcyYMYNdu3bZ1s+ZM8dfVThvsxZCx9bQqlmga+J/sxcadGxt0bJZ8Fzp5qdQPvZQuONf95VBjepQKdG33LWDxdKVhu05Kj/tMGhQx6JsvG/5xqYWn66DHLfvtZtvsnA6ITwMmja0WLEmODoD678yqFHdyo39P+1NPlrpsMe+3R77DU0s1qw3cLt9r7VrYeJ0QlgYNG1g8fGa4Lm+/uZrJ1WreUlM9GWxbm6fw6pVYbb4d+xwcnUdD3FxvpWNm7jZsN6F2w0ffxxG5y45xMaCwwEDBmbRooU7EKHkO8vy30+g+aXFjho1ipkzZ7Jz5066du3KokWLcl977733/FGFfPHMAOjQMtC1CIwhAyzat7wAWmyAhPKxh8Id/74kKBuf17bLxMGxdIP0jLwyNS+z2Pitwd79vuUF/zNwuw2OpEGtyyyWrDBweyA9Az5eY3DwUHB0hPYnGZSN+/vYa1xm8eV3ebEv+p8Dt9sgNQ1qXW7x4ccO3B7IyICP1xokp/g5iPOQlOQg/oRjHxdnkZFukHFC/NWre/nuOxcH9vuO6fJlYbjdBmlpBnv2OEhNNXji8Sj69I5m+jsRRMeE7nkyWPlljtCaNWtYsGABLpeLHj160KtXL8LDw2ndujXWhdAdFJGQZZ1hSovjhMvEulfCg3dbPDzEgcPhmwdULNYizAWDH7QY9YZB594O4krCtXUtvvsxODpC5hlOv/bYLe6/y8uAZ1w4DItb2uTF/sgDXl59w8l/eruIK2XRsK7F90ESO5w5G3Fi/LWu9HLnndk892wUDge0bJ1D0VgTlwu8HvjmGxcvDs0gPBxeGRHJtCkRPNg32z8BFKBQumvMLx0hy7IwDN+HetFFFzFp0iR69uxJyZIlc9eLiARCQhnYtNUAfN+KSckQW9QiKjKvTHqGr0Nwa1tfmeQUeG2qQbFYX0Zp0P0WxWN9r701y6BiYnBc4CXEW2zemvet/3exd2rrAeBQCrw+1UGxWNifBIPu902cBpg6y0HF8sERO0B8vMXWrXnfQckHDYoWtYg8If6MDKh1pYfWbXxDXodTDN6eFkFsrEWpUhaNG3tyJ1ff0MLNzOkRQPB3hEKJX4bGWrVqRY8ePdi0aRMAVapUYdy4cQwYMOCUOUMiIv50bT2LTT/BH3t8y3MWGzRvZP8yT0qGngMcHEv3LU+cbtDmBgvDgLmLDMZP9X2ZJqfA+x8atL0hODoDDetZbPrJyI193mIHzU4Te68BrtzYJ0130Lq56Yt9sYPXp/q+Rg6lwAcfOmhzY3DEDlCnroetW53s2eOLYcmScK691j7H51Cyg0cGRpN+PP6ZMyJo3syDYUCTpm7WrHGRne3LLn3xuYtq1bz+DkPOk18yQn379qVOnTpEn3BPYp06dZg/fz5Tp071RxVERE6rVAl46QmTAc868LihQnn4v6dMftwGz450MH+KSeWKcM/tFt3ud2BacHVNi6cH+L7w+9xh8cQwBx3u9k2wfuhui5qXBTiof6hUCRj6uJdHnvNN/q1QzmLYU162bDN4fqSTeVM8x2M36f6AKzf2J/v7vux7dzd5apiTjnf7vkoeuNtLjerB0xEqUcJi8OAsXnw+Eo8HEsqZPP5EJtu3Oxg9KpJJb6ZToaJJ127Z9HsoGtOEGjW99Hs4C4D2HdwcPWrwwP3RmF6oUsXk/gcyAxxV/giloTHDCsJJOub+qoGuQsCYBNczOvKbQ098CFmh3va9Z5rMFCKSzMLRwThXFcrv8+v+ai5+zm/72tz+Bb/t63T0QEURERGx0QMVRUREREKAMkIiIiJiE3yTZs6dMkIiIiISspQREhEREZtQumtMGSEREREJWcoIiYiIiI0yQiIiIiIhQBkhERERsQmhm8aUERIREZHQpYyQiIiI2GiOkIiIiEgIUEZIRERE7EJokpAyQiIiIhKy1BESERGRkKWhMREREbHRZGkRERGREKCMkIiIiNhYmiwtIiIiUvgpIyQiIiI2miMkIiIiEgKUERIRERE7ZYRERERECj9lhERERMRGd42JiIiIhABlhERERMROGSERERGRwk8ZIREREbHRc4REREREQoAyQiIiImKnOUIiIiIihZ86QiIiIhKyNDQmIiIiNposLSIiIhIClBEKMg71XSVEhXrbd+MNdBUCyhtCk3cvCCH0eYf2mUVERERCmjJCIiIichLNERIREREp9JQREhERETvNERIRERG5sCxZsoQ2bdrQokUL3n333VNe/+233+jRowft27fnnnvu4ciRI2fdpjpCIiIiYmf58ecfOnDgAGPGjGHWrFksWrSIOXPm8Msvv+RV2bJ44IEH6NOnD4sXL+ayyy5j8uTJZ92uhsZEREQkYNLS0khLSztlfWxsLLGxsbnL69ato0GDBhQvXhyAli1bsmzZMvr27QvAli1biIqKomnTpgDcf//9p93uydQREhERETs/Pln6nXfeYfz48aes79u3L/369ctdTkpKIi4uLnc5Pj6eTZs25S7v2rWL0qVL8/jjj/PTTz9RtWpVnnnmmbPuXx0hERERCZi77rqLjh07nrL+xGwQ+Ia+TmYYeR02j8fDl19+ycyZM6lZsyZjx45lxIgRjBgx4m/3r46QiIiI2Jymz1FgTh4CO5MyZcrw9ddf5y4nJSURHx+fuxwXF0elSpWoWbMmAO3atePhhx8+63Y1WVpEREQueNdeey3r168nJSWFzMxMVqxYkTsfCOCqq64iJSWFbdu2AbB69WquuOKKs25XGSERERGxuwCfI1SmTBkGDhzInXfeidvtpnPnztSqVYs+ffrw8MMPU7NmTV5//XWGDBlCZmYmZcuW5ZVXXjnrdg3rdINuFzhzf9VAV0FExK+yLXegqxBQB7xZga5CQF2UuM+v+6s05ewdiPzyxz2P+W1fp6OhMREREQlZGhoTEREROz/ePh9oygiJiIhIyFJGSERERGyMoJs9fO6UERIREZGQpYyQiIiI2CkjJCIiIlL4KSMkIiIidrprTERERKTwU0ZIRERE7DRHSERERKTwU0ZIRERE7JQREhERESn8lBESERERO2WERERERAo/ZYRERETETs8REhERESn81BESERGRkKWhMREREbExNFlaREREpPBTRkhERETsQigjpI7Qv2RZ8NQIqFIZenUNdG38K5RjB8Wv+Atn/GvXG7z2ppMct0GViy2ef8xDTLS9zOz5Dt5b4CQi3OLiShZPDvBSLBaOpMGwMU62/+IgsohFh9Ym3TqZgQnkHG3c4GLaWxG43VD5YpOBj2YSfVL8ixaEsXhhOOERULGiyUMPZxIb63ttyaIwln0UTnYOVKniZeCjWYSH+z8OOXcaGvsXft0JPQfCsk8CXRP/C+XYQfEr/sIZf0oqPPeyi1Evelg0w01iOYtxk522Ml99ZzBtlpPJr7qZO8VD4wYWQ0f5rqFHvu4kKhLmv+1mxgQPn290sHZd8Nx2nZpq8OrIIjzzfCZT3kmnbILJ1LeK2Mp8/52Tue9FMGJUBm9MTqfeNR7GjY4E4PPPXCxaGM7wkelMnpJOdo7Bgg/UCwo2fusI7dy5kwMHDgAwb948XnrpJT766CN/7T5fzFoIHVtDq2aBron/hXLsoPgVf+GMf/1XDq6oblEp0bfcpb2X/610YJ0wLPLTdoNr6piUifct39DEZM16A7cbtm43aNvCxOmEsDBo0sDk4zXBc3397ddOqlXzUj7Rl8Vq1z6H1avCbPH//LOTq672EBfnW9m4sZuNG1y43bByRRi3ds4hNhYcDnh4QBY33OgORChyHs46NDZ16lTGjx+P1+ulXLlyVKtWLfenatWqJCYmnnUnb7/9NjNmzMA0TRo0aMC+ffto0aIFH3zwAb///jsPPfRQvgRT0J4Z4Pt3w7eBrUcghHLsoPgVv+/fwhb/gSQoG5f3rV8mDo6lG6RnkDs8VuMyi9nznezd76VcWVj0Pwdut0FqGtS83GLpxw5q1/TizoFVax24gmjCxcGDDkqfEH9cnEVGukFGBrnDY9Wre1m0IJwDBwzKlLFYvjwMt9sgLc3gzz0OUlMNnnoiipRkgxo1vfS+NytA0eSvULpr7KxNdtKkSbzyyivUqlWL3bt3s2PHDrZv387atWv5+eefAahSpQqzZ88+4zY++OADPvroI5KTk2nXrh0bNmwgIiKCLl260Llz56DpCImIFCbmGb7snCckdepcaXHfXV4GPePCYUCHNibFYi3CXDDoAS9j3nDStbeL0qWgQV2TH34MnoyQeYbpTCfGX7OWlzt6ZPPis1EYDmjZKoeiRU3CXODxwrffuHh+aAbh4TDq5UimTY3ggYey/ROA5IuzdoRiYmK4/vrrcblcxMfHU6dOHdvre/bsye0QnYlpmoSHh1O+fHl69epFRERE7mter/ccqy4iIucjIR5+3Jo3pycpGWKLWkRG5pVJz4A6V5p0bOvrNRxKgQlTnRSLhf1JMOB+38RpgGmzHFQoHzyphPh4i23b8uJPTjaIKWpR5IT4MzKg5pUeWrXxDXkdTjF4Z1oERWMtSpWyaNTYk5s9an6jm3dnRACFoCOkP7GR595772XevHlnfD0xMZFmzf5+4Pymm27ijjvuwOv10q9fPwC2bdvG7bffTuvWrf9llUVEJD80rGey6SeDP/b4lt9f7OT6RvY0ycFk6D0gjGPpvuXJ0520am5iGDBvsZMJU32Tqw+lwPwPnbS+MXjuGqtT18O2n5z8ucf3Vbh0STgNr7XP8Tl0yMFjg6JJPx7/uzMjuL65B8OAJk3drF3jIjvbd1fhui9cVK2mi/tgc9aM0IgRI3C73Xz22Wc0adKEyy67jGrVqhF54iXDWfTv35+vvvoKpzPvboTw8HD69evHddddd241FxGR81KyBLzwuIfBz7lwuw0Sy1m89JSHLdsMXhjpZO4UDxdVhF63e+nxQBimBVfVNHmiv+/L/p7uXp4e5uLWu11YwP13e6lRPXgyQsVLWDzyWBZDX4jE44GEBJPBT2SyY7uDMa9G8sbkdCpUMPlPt2z6943GMuGKGl4eetg3D6hdezdHjxr0vT8a04RLq5jce39mgKPKJ8FzGM+bYVnW34a7e/dutm3bxvbt29m+fTvbtm1j7969JCYmsnz5cn/V08bcXzUg+xURCZRsK7TvRjrgLRyTkM/VRYn7/Lq/i8eO9tu+fhswyG/7Op2zZoQqVKhAhQoVaNGiRe66jIwMduzYUaAVExERkQAJoYzQOU3vj4qKonbt2vldFxERERG/CqInPoiIiIg/hNJzhILngQ8iIiIi+UwZIREREbFTRkhERESk8FNHSEREREKWhsZERETETkNjIiIiIoWfMkIiIiJio9vnRUREREKAMkIiIiJiZxmBroHfKCMkIiIiIUsZIREREbHTHCERERGRwk8ZIREREbHRXWMiIiIiIUAZIREREbFTRkhERESk8FNGSERERGw0R0hEREQkBCgjJCIiInbKCImIiIgUfuoIiYiISMjS0JiIiIjYaWhMREREpPBTRkhERERsdPu8iIiISAhQR0hERERCljpCIiIiErI0R0hERETsNEdIREREpPBTRkhERERsdNeYiIiISAgIyozQfu+xQFchYCYfrhfoKgRUo+gdga5CQEU7sgNdhYAJM8xAVyGg3FZoX7eO29sh0FUIqDmJft6hMkIiIiIihV9QZoRERESkACkjJCIiIlL4KSMkIiIiNrprTERERCQEqCMkIiIiIUtDYyIiImKnoTERERGRwk8ZIREREbHRZGkRERGREKCMkIiIiNgpIyQiIiJS+CkjJCIiInbKCImIiIgUfsoIiYiIiI3uGhMREREJAcoIiYiIiJ0yQiIiIiKFnzJCIiIiYqeMkIiIiEjhp4yQiIiI2OiuMREREZEQoI6QiIiIhCwNjYmIiIidhsZERERECj9lhERERMRGk6VFREREQoAyQiIiImKnjJCIiIhI4aeMkIiIiNgpIyQiIiJS+CkjJCIiIjZGoCvgR8oIiYiISMhSRkhERETsQmiOkDpCx63f4OSttyJw5xhcfLGXwYOziI62l5k/P4yFC8MJj7CoVNGkf/8sYmN9ry1cFMZHS8PIzoGqVU0GP5pFeLj/4zhXf35zjB9mHsT0WBSvFME1D5YlLMppK7N741E2v5eM4YDwaCf1HyxL0bLh5KR7+XLCftL+zMayoPL1xbi8Y6kARXJuftxosXiahccN5SvD7QMNIqPtyeFPF1msXWwRFgFlK8B/+hpEF80rc/igxagBFk9OMIgpFlyJ5R82Grw/1YnHDYmVLXoN8hJ5UvtfudDBqsUOwsKhXEWLO/p6iYmFnGyYMd7J79sNLAsurm7Ro6+X8IjAxHIuvtvoYO4UJ243VKxs0fsRD1Enxb9ioYMVi5yEH4//7n4eYmIhIx3efNXFvt0GpglNWpjc3NUbmEDOQagf+yPfJ7Pv/d+wPCZFEmOoeE91nJF5X40pX+wnadnu3GUz00PO4WyuGH0tYcXCSV71J4fW7sXMMYm6qCgVelXHEabBlmCiowWkphq88koRXng+k+nT00koZzL5Tftv8nffOZn9XjivvprBW29mcM01Hl4dXQSAtWtdLFgQxqhRGUybmkF2Nrz/fvD0grKOeNg4fh9NBpen3WsXE1MmjO9nHrSV8WSbrB+3lyaPlaf1q5UpXy+Gb6ccAGDze8lElnLRZuzFtHz5In5Zfpjk7ZmBCOWcHE21mDnaovczBs9OcVAqARZPs18O7fjBYuU8i34jDJ6c4OCKegazx+WV2bjSYswjFkcO+bv25y8tFaaMcvLQsx6GT/UQl2Axb4r91LD1e4OP5joY/LKHFyd6qFXf5J2xvo7yklkOTC+8ONHD0Ike3Nmw9L3gObWkpcKbo1z0f9bDqGlu4hMs5kyxXyP+9L3BkjkunnzFzf9NclO7vsmUsb4y77/tpGRpixFvunlxvJtVHzr5+afg6AiH+rH3pOWwe8o2KvetwWUjGhARH8neeb/aypRsVJbqQ+tRfWg9qj1XB1excBLvqEJYsXBSvz7IwZV7uGRwbaoPq4+ZY3Jw+e4z7C24GJb/fgItIC12xIgRgdjtGX31tZNq1UwSE31HpEN7N6tWhWGdcIB27HBQp46XuDjfyiZNPKxf78LthhUfu/hPFzexseBwwKCB2bRo4Q5EKOdk/w/plLq0CEXL+Tpvl7Yszh+fpWGd8AFYJmCBO8MEwJNl4gjzneyv7hXPVXfFA5B52IPXbREWFTwnw23fQqWqEF/eF0+TtgZfrcYW/66foVptKBHnK3NlY/hxI3jcFqmHLDats3hgaHB8+Z1syzcGlatZlC3vW27ezmTDaoet/e/82eDyqyxKxvmW6zSy+H6jgccN1Wpa3Hy7F4cDHE6oeKlF8oHg+Sw2f+OgclWTssd//2+42cu6Vfb4f//ZQY2rTEodj79uY5PvNjjwuKHHg15uv8+XAUpNAbebU7JJF6pQP/ZpP6YQVbkoEWWjACjVrByH1x+w/e6f6MBHu3DFhlO6me8DS/liP/GtKuCKCcNwGFS4qyolGpX1W/0lfxT40NiTTz55yrrVq1dz5MgRAIYPH17QVTirg0kO4uPN3OW4OIv0dIOMDHKHx6pXN5m/IJz9+w3KlrVYtiwMt9sgLc1gzx4Hh1NNHns8kkOHDGrW9HLfvdkBiubfy0j2EFU6LHc5qlQY7gwTT6aZOzwWFumg3n1l+fipP4go6sQ0LVoMqwSAYRgYTlg3bi+71x8lsX5MbqcqGBw+CMXj8paLx0FWhu/nryGCi6rBmkWQcsCiZBmDDSvA44b0NCheyqDPs3+d/C+Ay5t/KeWgQcm4vHqXiIPMDMMW/8XVLFYudJB8AEqXgc9WOPC4DY6lQY26ee9NPgAfz3dw14DgGRo6dNDI7eAAlDwef2ZGXofmkmomKxaE5ca/drkv/qNpUKIUOJ0wYYSLr9Y6qNPIJCExONpBqB97d0o2YSWL5C6Hl4zAzPRiZnltw2MAnqM5HFy2m6ov1M1dl30gA09aUX4d9QPu1GxiqhYn4bZL/Fb/AhUcTThfFPhle/Hixfn000+pXr069evXp379+kRFReX+/0JgnuGAO074dK680sudd+bw7LOR3Hd/FIYDYmMtXC4Lj8fgm2+cPPdsJhPfyOBomsGUKcEzSH6mqx/DkXdll/pHFj/OS6bNuMrc8talXHFrKT4f+aftvdf2L0enaVXIOWayZV5ygdc7v5whfBwnTJG6tKZB6+4Gk1+0eLmfiWFAVFFwhp3+vcHkjPGf0P6r1bLocIeX115w8cJDThwGRBe1cJ0Q/84dMHyQixs6mNRuEDxnUcs8/foT469ey6JjDw9jng/jmQfDMBwQc1L8Dz7h4Y0Pckg/arBgpvPUDV6AQv3Yn/kDODWrdejTvcReVZqIuMi8t3stjm45zEUPXUHV5+viSXez7/3fCqq2UkAKPCP0+OOP07RpU8aOHcugQYO45ppreOedd+jYsWNB7/ofKxNvsnVr3kdx8KBB0aIWkXntnYwMqH2lh7ZtfENeKSkG06ZFEBsLpUqZNG7syc0e3djCzfTpwdMRiiodxqGfs3KXMw95CI9x4CqSdzbc9306patHUrSsL9NTpVUJvns7iZyjXlJ+zaJYpQiiSoYRFumgUuOi7N5w1O9xnKsScbBzW97ykWSIioGIInknw6wMiyq14NpWvs8k7bDFh9Mhuqi/a5v/SsZZ/Lot71gfTvZ90UWc0P4zM3xfiE1bewA4chjmv+PIjX/jJwYzxjvp/pCXhs2D6IsQKBVv8eu2Eya9H4+/yEnxV69lcn1rX6/pyGH44G2IKQqbvjKoUNmiRGkoEgkNm3n56vPgGBoO9WMfVqoI6b/lnavch3NwRrtwRpzakT38ZRKJ3avY3188nGJ14nKzRyUaluHA4p0FWmfJf375bW3YsCGTJk1i1qxZvPzyy3i9F1bqtG5dL1u3Otmzx3cyXLIkjEbXemxlkpMNBgyMIj3dtzxjRjjNm7kxDLiuqYc1a1xkZ/suML743EX1ahdWjH8noXY0yTsyObo3B4CfVxymfD37N3yJi4twcEsGmam+z+XPL48SHR9GRKyLXeuO8uPcQ1iWhddtsmvdUf6/vTuPr+He/zj+PtkQtUUWdLlqKUopKUJrry2UarVV99ppUdJaq5ZStaYq2lqKllJxaym1tEVQaonaetFWq7VVCElssQRZzu+P+OWam4S0khk583o+HufxMJPvzHy+mTPxOZ/vd+YEPJZLJklIqhCYmgjFnEz9I77la6ceq2Vsc0uPC0QAACAASURBVPGs9MFgpxKupLZZs9CpJ+qnDgvmdpUCnTpy0KHTJ1OXv1vtpqq1jP+hXTgrTRzkoYSb7/+V4W6q2SC1Mrbre4fCp7trwPjc9x+hJD0WmKI/Drrp9M3rf8Nqd1WrZSwTnT/r0NiBXrp6s/9fLfBQrZv9/+F7dy1b4CGnU0q8If2w2U2PPp47fg92P/cFKvno6uGLun76qiQp7ruTKlTVN127pCuJunEmQfnLFDKsL/yEvy7silHKjWQ5nU5d3Bsn74cLmhJ7jnOa+LKYw5nZuEgOWbJkib799lvNmTPnb+/j1MkS2RhRqh073DX7kzxKSpJKlHDqrSEJio5203uT8uqT2akXyfLlnvpqhaecKQ5VeixJr4dcV548UnKytGCBl77b5KGUZIfKlk1W//7pb7/PDrPOV8/+nUo6teey9oWn3j5/XzFPBfUtoctnbmjnjNNq/v7DkqRD357X79+el5uHQ173ueuJ7gEq9FAe3biSrF0zT+vin9clh0MP1LhPj73kaxhayy5P5j+U7fuUpJ933rx9PknyLS51HORQXLS0cIpTb01P/byweaVT369yypkila4ovfCaQ155jH3s0yxFExbl3O3z+d1yZu7Zvp0OfXnzFmr/Ek51H5Ss2NMOzZ3srtEfpya/61e4aePK1Im0ZSum3kLtlUd6s7OHrl5JnSvz/8pWTFGHvpmMOf1Nno7s3d+t/vODmxbf0v+eg5MUE+3QJ5M9NG5mahV43VduWr/SXSlOqVwlpzr1SZJXHunKZWnuBx6KOpZ6zgOfTNHzHZMNw0vZIdGZM59bc8O5l6QPTjXJ9n1KUvy+szq19LCcSU7l8c+nh3pU0I3YBP055zeVfzf17+3VI/E69vEvejQ0yLCtM8WpMyuP6fzOGCnFqXz/KKAHO5dLN78oOyyq9XG27/N2qoSEmXasfR/2M+1YGTE9EcoOOZEI5RY5lQjlFjmVCOUWOZUI5QY5mQjlBjmVCOUWOZUI5RZmJ0KP9zUvEfrPR9YmQva+sgAAgK3xZGkAAGCU68aK/j4qQgAAwLZIhAAAgMG9+hUbq1atUnBwsBo3bqzw8PBM223atEkNGzbM0j4ZGgMAAPe8M2fOKCwsTMuWLZOXl5fatWunmjVrqkyZMoZ2cXFxmjhxYpb3S0UIAAAYmfgcofj4eEVFRaV7xcfHG0Lavn27goKCVLhwYXl7e6tp06Zas2ZNutCHDx+uPn36ZLmrVIQAAIBl5s2bp6lTp6Zb36dPH/Xt2zdtOSYmRn5+//1iQH9/f+3fv9+wzfz58/Xoo4+qSpUqWT4+iRAAADD4q3N37kanTp0y/NqtggWNT+nO6LGHtz7d/9ChQ1q3bp0+++wznT59OsvHJxECAACWKViwYLqkJyMBAQHavXt32nJMTIz8/f3TltesWaPY2Fg9//zzSkxMVExMjNq3b6+FCxfedr/MEQIAAEb34HeN1a5dW5GRkTp37pwSEhK0bt061a1bN+3nISEhWrt2rVasWKFZs2bJ39//jkmQRCIEAABygYCAAPXr108dO3bUs88+q5YtW6py5crq0aOHDhw48Lf3y9AYAAAwukefLP3MM8/omWeeMaybPXt2unYPPPCANm7cmKV9UhECAAC2RSIEAABsi6ExAABgYObt81ajIgQAAGyLihAAADCiIgQAAOD6qAgBAAADRwZfZ+GqqAgBAADboiIEAACM7FMQoiIEAADsi4oQAAAw4DlCAAAANkBFCAAAGFERAgAAcH1UhAAAgAFzhAAAAGyAihAAADCiIgQAAOD6SIQAAIBtMTQGAAAMmCwNAABgA7myItTpoTpWhwCLbHNWsjoES3mU/IfVIVgrIcHqCCyTHHfW6hAs5ZbvutUhWCve5ONREQKAe4yNkyAAOSdXVoQAAEDOYY4QAACADVARAgAARk77lISoCAEAANuiIgQAAAyYIwQAAGADVIQAAIARFSEAAADXR0UIAAAYOFKsjsA8VIQAAIBtURECAABGzBECAABwfSRCAADAthgaAwAABjxQEQAAwAaoCAEAACO+dBUAAMD1URECAAAGzBECAACwASpCAADAiIoQAACA66MiBAAADJgjBAAAYANUhAAAgBHPEQIAAHB9VIQAAIABc4QAAABsgIoQAAAwoiIEAADg+kiEAACAbTE0BgAADJgsDQAAYANUhAAAgFGKfUpCJEKZqBFcVd3GvizPPJ46euBPvd/9Y129lJBh20FzeunoTye0dPJqk6PMOXbof43gauo2rn1qH/cf1/vdZ6TrY2ZtChS5TyHTe6j04yV17co1rf3sO62YukYPVXhAQ8NfT9vezd1NDz/2kN55/j1tXb7T7C5mWfUGFdRlUHN5enno6K/RmjJksa5evp5h2/6hL+n4odP68pPNkiQ3N4d6v9NGj9UoLUnatemgPhmfe94L1RtVVJehrVP7fvCkpvQP19XL1zJs239KBx3/9ZS+/HhD2rovfpqguOiLactfzliv75btyvG4c0qN5lXVdWw7eXqlXvuTX5mZ6bU/8NNeOvbTCS0Nyz3n+3/VaFpZXUa2lWceDx39KUphfebo6qWMz/+AGd107JeT+vKjNZIk74L51G9qFz34SHE53Bxav3C7lkz5xszwkQ0YGstAId8CGvhpL41+YbK6PtpP0UfOqNv49unaPVT+foVGjFDdF2pZEGXOsUP/C/kW1MA5vTW67SR1rfC6oo+eUbcJ/8xym56TOynhyjV1r9hPIbWGqUazqqrZopr+PBilntUGpb32ROzTxoVb7+kkqJBPfvWf+JLG9J6vHk+H6vSJc+oyuEW6dg+W9tf4BT1Vp0UVw/qGbQJ1/8P+6tV8knq3eF+P1Sytp5pXNiv8u1Ko6H3qP6WDxnSfrR51Ruv08Th1GdY6XbsHywZo/JIQ1WlVzbD+/tL+unThqvo0Hp/2ys1JUCHfAhr4SU+NfjFM3Sr1V/TRGHUb93K6dg+WL6HQdcNVt22QBVFmn0JFC6j/9G56t8M0dQ8cquhjseryzgvp2j34SHFNWDVYddpUN6zvNLyN4k6dV8+gEQqpP1otuzVQhZsfCHI9p4kvi5mSCO3fvz/t35GRkZowYYImTZqkffv2mXH4vyywSRUd2n1YJ/84LUla9XGEGrV/Kl27Vr2baN28Tfp+SaTZIeYoO/Q/sEllHdp1Sx9nrFOj9nWy3KZsYCmt/3yzUlJSlJSYpB++2au6zxsTwkpPlVed54P0Qa9ZJvTo76tW5xEdOnBCp47FSZJWL9iuBq2rpmvXssOTili6U1u+Nl63bu5uyuvtJU8vD3l6ecjD012J15NMif1uVatXQYf+c1ynjsZKklbP26IGz1VP165l53qKWLRDW1buNax/9IlSSklxasLS1zV9w1C179dcbm4OU2LPCYGNK+u33Yd16uZ7fvXMCDV8OYNrv1dTrZ23Wd8v3WF2iNmqWqOKOrT3qE4dPiNJ+vrTjWr4Qvrk7plXGikifIu2LDcmuTMGL9TsYYskST7FCsszj4euXMy4eoZ7lymJ0MiRIyVJ4eHhGjdunIoVKyZfX1+9/fbbWrBggRkh/CV+DxRV7ImzacuxUWeVv5C3vAvkM7SbGjJX6xdsMTu8HGeH/vs96KvYqLi05Yz6eLs2v+78Q093qCd3D3flzZ9XTz0XJJ/ihQ3HeOW9jpo7/N+ZDivcK3yLF1Zs9IW05bjTF5W/QD5535fH0G7GqOXa+NXe/91c65fu0uWLV/V55AiF73hbp47H6YeNv+R43NnBt0RhxZ46n7YcF31B+Qvmk/d9eQ3tZgxbrI1L01f13D3c9OPmXzWi/TQNahOmavUrqFW3+jkddo7xe6CoYqPufO1Pe32uNoTnzmv/Vn73+yg26lzacuzJ8zf7azz/0wcu0IYvMv7Al5KcosGzX9HMHWO0f+uvivo9OkdjNovDad7LaqYOjS1evFjz589X586d1blzZ4WHh9+TiVBmn+hSklNMjsQaduh/Vvp4uzYzB8yTnE7N2BuqUcsGae/6fUq88d8qyKO1HlEh3wLauHBr9gaeAzLrZ3Jy1v5C/TOkiS6eu6L2Nd5RhyfHqEAhbz3XrV52hphj3Nwy/hOYnMX3+prw7fp4xBIl3kjSlfgELZ+1UbWbV7nzhvcoRya/D1e69m/lyPS9/9f6G9pjll58uK8KFLlP7YekH1rFvc2URCgpKUkpKSkqWrSovL2909Z7eXll+ofISjEn4gyf7n3v91H8ucu6djXjyaOuxg79j/kzTj7FiqQtZ9TH27XxLuit2YMX6JXKAzSk6btypjh16vDptLb1X3pSEZ9vltN5D3zcuYOYkxfk41cgbdk3oJAuXbiq6wk3srR97aaPad2SnUpKTNbVS9e0ftluVa6VO+ZJxJw8Jx//QmnLvsUL69L5K1nue8O2NVSyQom0ZYccSkpMzvY4zRJ74s7XhSuJjTonn2K3/K0rUUSXzl/W9atZO/+BjSqlbX/tynVtWrJDZar8I0diNZ3Tad7LYqZkIUWKFFG9evX0xx9/pA2TRUZGql27dmrWrJkZIfwle9btV4WaZXV/mWKSpJavNlbkyt0WR2UeO/R/z7p9qhB0Sx97NlHkil1ZbvNMz8bqNPolSVJh/0Jq3v1pQ/Wnct1H9eOGn8zoyl3bu/WQylf9h0qU9JUkBf8zSJHrf87y9n/8HKW6NydQu3u4Kejpivr1x+M5Emt227vpoMoHllSJh/0kScEdn1Lk2v132Oq/SpYrrg6DW8rNzSGvvJ56pmtdfb9yT06Fm+P2ROxXhZplVOL/3/OvPK3IVa517d9qz4afVL56KZUoHSBJatG1gSK//jHL29dtU13/ulkB8vTyUJ3namjf9wdzJFbkHFNun58/f74k6ciRI4qPj5eUWg0KCQlR/fr1zQjhL7kQG69J3WZoxOL+8vTy0KkjpxXaaZoeCSyl/rNeVc/AN60OMUfZof8XYuM1qet0jVgyILWPh88otNPU1D7O7qWe1QZl2kaS/j1+ud6c31ez9r8vh8Ohz99ZrEO7D6ftv0TZYjpzLMaq7v0lF89eVtjgRRo2raM8PN0V/edZTRrwb5V97AG9Pv4F9WkZdtvtZ41ZqV6jntWsiMFKSU7Rf7b/riUzvzMp+rtz8exlhb2xQMNmd5eHl4eij8VqUsh8la3ykF6f9E/1aTz+ttuHT/5Gvce+pBnfDZO7h7u2rP5Ra8K3mxR99rsQG69J3T/WiEX95OnpoVNHzui9LtNUNrCU+s98Rb2eGGJ1iNnqYtwlTe49R8Pn9049/0dj9N6rn6hs1ZJ646Mueu2pkbfdftawL9R3Sid9vONdOZ1S5Nd79dX0CJOiz1n3wtwdszicuaF2/z8au79kdQiwitM15ypklUdJFym7/x0J9/ak85yWHHf2zo1cmFu+fHdu5MLWxM819XgNmk407VjfrbX2wzUPVAQAAEa5rkTy9917M5UBAABMQkUIAAAYOHLfrJm/jYoQAACwLRIhAABgWwyNAQAAIxvdoEtFCAAA2BYVIQAAYMBkaQAAABugIgQAAIzsUxCiIgQAAOyLihAAADBijhAAAIDroyIEAAAMHPYpCFERAgAA9kVFCAAAGDFHCAAAwPVREQIAAAYOvmsMAADA9VERAgAARswRAgAAcH1UhAAAgJF9CkJUhAAAgH2RCAEAANtiaAwAABg4mCwNAADg+qgIAQAAIypCAAAAro+KEAAAMOIrNgAAAFwfFSEAAGDAXWMAAAA2QEUIAAAYURECAABwfbmyIuRwd7c6BMu45ctrdQiWcgT4WR2CpZIOH7M6BOs4bXQbS0Yc9v7cmnzlqtUh2AsVIQAAANeXKytCAAAgB9moAEtFCAAA2BYVIQAAYMBzhAAAAGyARAgAANgWQ2MAAMCIoTEAAADXR0UIAAAYURECAABwfVSEAACAERUhAACAe8uqVasUHBysxo0bKzw8PN3P169fr9atW6tVq1bq3bu3Ll68eMd9kggBAACjFBNfWXTmzBmFhYVp4cKFWrFihRYtWqQ//vgj7eeXL1/WqFGjNGvWLK1cuVLlypXTRx99dMf9kggBAADLxMfHKyoqKt0rPj7e0G779u0KCgpS4cKF5e3traZNm2rNmjVpP09MTNSoUaMUEBAgSSpXrpyio6PveHzmCAEAAAMzv2Jj3rx5mjp1arr1ffr0Ud++fdOWY2Ji5Ofnl7bs7++v/fv3py0XKVJETz/9tCTp2rVrmjVrljp06HDH45MIAQAAy3Tq1Elt2rRJt75gwYKGZWcGyZnD4Ui37tKlS+rdu7fKly+f4X7/F4kQAAAwMrEiVLBgwXRJT0YCAgK0e/futOWYmBj5+/sb2sTExKhbt24KCgrS0KFDs3R85ggBAIB7Xu3atRUZGalz584pISFB69atU926ddN+npycrJ49e6p58+YaNmxYhtWijFARAgAARin33nOEAgIC1K9fP3Xs2FGJiYlq27atKleurB49eigkJESnT5/WL7/8ouTkZK1du1aSVKlSJY0dO/a2+3U4Mxp0u8c18WpvdQiWccuX1+oQLOUI8LtzIxeWdPiY1SFYx/kX7rN1RQ4K+HYWkbzI1OM1LzfEtGN9+9sE046VESpCAADAKPfVSP42PmIAAADbIhECAAC2xdAYAAAwYmgMAADA9VERAgAARlSEAAAAXB8VIQAAYHQPPlAxp1ARAgAAtkVFCAAAGNnoSe5UhAAAgG1REQIAAEbcNQYAAOD6qAgBAAAjG901RiJ0U43mj6vrmHbyzOOhowdOaPIrs3T1UkKGbQd+8qqO/RylpWFfG9b7PeCjD7aMVs8n3lL82UtmhJ1tajSprC4jn5dnHk8d/fmEwvrM1dVL1zJsO2B6Vx07eFJffrRWkuRdMJ/6Te2iB8sWk8PNTev/vU1LpnxrZvh3rXr98urSv5k8vTx09LdoTRm6VFevXM+wbf8JL+j4oTP6cs73kqT7CuVTn3faqHT5ErqWcEMRy3Zr5efbzQw/W9UIrqpuY19OfS8c+FPvd/8402th0JxeOvrTCS2dvNrkKO9OjeBq6jaufWof9x/X+91npOtjZm0KFLlPIdN7qPTjJXXtyjWt/ew7rZi6RpIU1DJQgz7ro9g/49L206/uCCVczvhauhfZ4fxnxs59tzOGxiQV8i2ggbNf1eiXpqhbpYGKPnpG3ca2S9fuwfIlFLp2mOq2DUr3s6f/VUfvbxwp3/t9zAg5WxUqWkD9p3fVux2mqfsTQxV9LFZdRrVN1+7BR4prwqpBqtOmumF9p2FtFHfyvHrWelshDUarZdcGqlC9tFnh37VCRfKr//gXNKbv5+rRbJJOnzinLgObp2v3YGl/jZ/XQ3WaVzasf3XoM7p25YZeDX5f/V6cpifqllON+uXNCj9bFfItoIGf9tLoFyar66P9FH3kjLqNb5+u3UPl71doxAjVfaGWBVHenUK+BTVwTm+NbjtJXSu8nnq9T/hnltv0nNxJCVeuqXvFfgqpNUw1mlVVzRbVJEmP1i6npe+vVM9qg9JeuSkJssP5z4yd+54hp9O8l8VMS4S2bNmi+Ph4SdJXX32l0aNH68svvzTr8LcV2Liyftt9RKf+OC1JWj1zvRq+/GS6dq16NtHa+Zv1/dIdhvU+xQurdqtADW8dakq82a1aw4o6tPeoTh2JkSR9/el3avhC+mTvmR4NFbFgq7Ys32VYP+PNhZo9fJEkyadYYXnm8dCV+Iw/Rd2Lqj1VVocOnNCp42clSav/vUMNWlVN167lP2spYtlubfl2v2F9mYr3a8OKvUpJcSopMVk7N/2qp5o9Zkrs2S2wSRUd2n1YJ29eC6s+jlCj9k+la9eqdxOtm7dJ3y+JNDvEuxbYpLIO7bqljzPWqVH7OlluUzawlNZ/vlkpKSlKSkzSD9/sVd3nU/9TrFirnB5vUEnTdk3U5M2j9VidCib27O7Z4fxnxs59tztTEqGxY8dq5syZun79uqZMmaJVq1apTJkyioiI0JgxY8wI4bb8HvBRbNTZtOXYqHPKX8hb3gXyGdpNe+MzbQjfmm77c9EXNPrFKfrz4MkcjzUn+D3go9iT59KWY0+ev9n/vIZ20weFa8OijC/+lOQUDZ7VQzMj39X+rb8p6vfoHI05O/kWL6zY6Itpy3GnLyp/gbzyzp/H0G7G6BXauOLHdNv/tu+EGrWuJncPN+X19tKTTSrJx69gjsedE/weKKrYE7deC2czvBamhszV+gVbzA4vW/g96KvYqP8OXWXUx9u1+XXnH3q6Qz25e7grb/68euq5IPkULyxJij97SSunr9Vr1d/Up0MXatSyQbmqSmyH858ZO/c9Q1SEste2bds0b948+fn5adOmTZoxY4bat2+vadOmadu2bWaEcFsOt4x/DSnJ9niglMPNkeH65L/Y/9BXZuvFUiEqUCS/2r/ZKjtCM4VbZv1PyVr/Z09YLaecmvrV6xoxraN+3P67khKTsjNE02T2u3ClayErfbxdm5kD5klOp2bsDdWoZYO0d/0+Jd5IPd/vtJ2kbV/tlCT9vO1X/bz9NwU2rpzhvu5Fdjj/mbFz3+3OlEQob968Ons2NdMuWrSorl69KklKSEiQh4f187VjT8SlfaKTJN/7fRR/7rKuXc14sqyriT1xVj4Bt/S/RBFdOn9Z16/eyNL2gY0qyqdY6vbXrlzXpqU/qEyVf+RIrDkh5tQF+fgVSFv2DSioSxeu6npCYpa2974vrz4N/Ua9WoZpWJdP5Exxpg2z5TYxNrgWYv6Mk0+xImnLGfXxdm28C3pr9uAFeqXyAA1p+m7q+T58WvkLeevlt9oYjuVwOJSUmJzzncomdjj/mbFz3+3OlESoT58+atu2rSZOnKhSpUqpQ4cOGjdunF588UV16dLFjBBua0/EAVWoUVYlyhSTJLV8pZEiV+2xOCrz7Nn4s8pXL6USpfwlSS261lfk1//J8vZ129TQv4akVoA8vTxUp0117fv+YE6EmiP2bj2k8o8/pBL/KCpJCn45SJEbfsny9sEv11SH15tIkgoXvU/NXqyhTauz/vu7l+xZt18VapbV/f9/LbzaWJErd1scVfbas26fKgTd0seeTRS5YleW2zzTs7E6jX5JklTYv5Cad39aGxduVcKla2rVu5meeq6mJKn04yVVrkYZ7VqTe94Ldjj/mbFz3zNko6ExU8oxDRs2VNmyZbV+/XodP35cjz/+uPLnz68JEyaocmXry8YXYuM1qcdMjfjidXl6eejU4TN6r+sMla32sPrP7KFe1YdaHWKOuhh3SZN7z9Hw+a/Jw8td0Udj9V7PT1S2akm98WFnvVZn1G23nzXsC/UN66iPI0fL6ZQiv/5RX81Yb07w2eDiuSsKe2uJhn30L3l4eij6z7OaNHiRyla6X6+Pbas+rT+47faLZ36nge+104zV/eRwOLTgo/U6dCDKpOiz14XYeE3qNkMjFvdPvRaOnFZop2l6JLCU+s96VT0D37Q6xLt2ITZek7pO14glA9Ku99BOU1P7OLuXelYblGkbSfr3+OV6c35fzdr/vhwOhz5/Z7EO7T4sSRr57ES99mE3dRz1olKSUjS2XViuepSGHc5/Zuzcd7tzOJ33QDr2FzXxSn9Lo1245ct750YuzBHgZ3UIlko6fMzqEKxjoy+BzJCDp53YWUTyIlOP17z4a6Yd69voaaYdKyNcWQAAwLasn6kMAADuLblvsOhvoyIEAABsi4oQAAAwoiIEAADg+qgIAQAAoxQqQgAAAC6PihAAADBw2ui5XVSEAACAbVERAgAARswRAgAAcH1UhAAAgBHPEQIAAHB9JEIAAMC2GBoDAABGKdw+DwAA4PKoCAEAACMmSwMAALg+KkIAAMDAyRwhAAAA10dFCAAAGDFHCAAAwPVREQIAAEZ86SoAAIDroyIEAACMnNw1BgAA4PKoCAEAAAMnc4QAAABcHxUhAABgxBwhAAAA10ciBAAAbIuhMQAAYMBkaQAAABugIgQAAIxsNFna4XTa6CtmAQAAbsHQGAAAsC0SIQAAYFskQgAAwLZIhAAAgG2RCAEAANsiEQIAALZFIgQAAGyLRAgAANgWiRAAALAtEqG/YNWqVQoODlbjxo0VHh5udTimu3z5slq2bKmoqCirQzHd1KlT1aJFC7Vo0UKhoaFWh2O6Dz74QMHBwWrRooXmzp1rdTiWmThxooYMGWJ1GKbr2LGjWrRoodatW6t169bat2+f1SGZauPGjXruuefUrFkzjRkzxupwkM34rrEsOnPmjMLCwrRs2TJ5eXmpXbt2qlmzpsqUKWN1aKbYt2+fhg8frmPHjlkdium2b9+urVu3avny5XI4HOrevbsiIiLUuHFjq0Mzxc6dO7Vjxw6tXLlSSUlJCg4OVr169VSqVCmrQzNVZGSkli9frvr161sdiqmcTqeOHDmiTZs2ycPDfv9lnDhxQiNHjtSSJUtUtGhRderUSZs3b1a9evWsDg3ZhIpQFm3fvl1BQUEqXLiwvL291bRpU61Zs8bqsEyzePFijRw5Uv7+/laHYjo/Pz8NGTJEXl5e8vT0VOnSpXXq1CmrwzJNjRo1NH/+fHl4eOjs2bNKTk6Wt7e31WGZ6sKFCwoLC1PPnj2tDsV0R44ckcPhUI8ePdSqVSstWLDA6pBMFRERoeDgYBUrVkyenp4KCwtTlSpVrA4L2ch+6f3fFBMTIz8/v7Rlf39/7d+/38KIzDV27FirQ7BM2bJl0/597NgxffPNN/riiy8sjMh8np6e+vDDDzVnzhw1a9ZMAQEBVodkqrffflv9+vVTdHS01aGYLj4+XrVq1dKoUaN07do1dezYUQ8//LCefPJJq0MzxfHjx+Xp6alu3bopNjZWDRo00BtvvGF1WMhGVISyyOl0plvncDgsiARW+f3339W1a1e9+eabKlmypNXhmC4kCvBXlgAAAzBJREFUJESRkZGKjo7W4sWLrQ7HNEuWLFHx4sVVq1Ytq0OxRNWqVRUaGipvb2/5+Piobdu22rx5s9VhmSY5OVmRkZF67733tHjxYh04cEDLly+3OixkIxKhLAoICFBcXFzackxMjC2Hiexqz5496ty5swYMGKA2bdpYHY6pDh8+rIMHD0qS8uXLpyZNmui3336zOCrzfPPNN9q2bZtat26tDz/8UBs3btS4ceOsDss0u3fvVmRkZNqy0+m01VwhX19f1apVSz4+PsqbN68aNWpkq9EAOyARyqLatWsrMjJS586dU0JCgtatW6e6detaHRZMEB0drddee02TJk1SixYtrA7HdFFRURo+fLhu3LihGzduaMOGDQoMDLQ6LNPMnTtXq1ev1ooVKxQSEqKGDRtq6NChVodlmkuXLik0NFTXr1/X5cuXtXz5ctvcKCBJDRo00NatWxUfH6/k5GRt2bJFFStWtDosZCP7pPV3KSAgQP369VPHjh2VmJiotm3bqnLlylaHBRN8+umnun79uiZMmJC2rl27dnr55ZctjMo89erV0759+/Tss8/K3d1dTZo0sWVCaFcNGjRIO/8pKSlq3769qlatanVYpqlSpYq6d++u9u3bKzExUU8++aSef/55q8NCNnI4M5r8AgAAYAMMjQEAANsiEQIAALZFIgQAAGyLRAgAANgWiRAAALAtEiEAAGBbJEIAAMC2SIQAZEnz5s1Vt25d/f7771aHAgDZhkQIQJasXr1aJUuW1Nq1a60OBQCyDYkQgCxxd3dXYGCgrb5wFYDr47vGAGTJtWvX9PXXX4tv5QHgSqgIAciSsLAwBQQE6MSJE7py5YrV4QBAtiARAnBHP/74o9asWaOPPvpIBQoU0KFDh6wOCQCyBYkQgNu6fv263nrrLb3zzjsqXLiwypcvzzwhAC6DRAjAbX3wwQeqWrWq6tevL0kqX768fv31V2uDAoBsQiIEIFP79+/XmjVrNHTo0LR1FSpUoCIEwGU4nNwCAgAAbIqKEAAAsC0SIQAAYFskQgAAwLZIhAAAgG2RCAEAANsiEQIAALZFIgQAAGyLRAgAANjW/wGumXmo8YhQRwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# optional\n",
     "# visual representation of grid search\n",
@@ -2474,9 +3019,7 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "pip3 install tensorflow"
@@ -2492,9 +3035,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "conda install tensorflow"
@@ -2509,11 +3050,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "inputs = (n_inputs, pixel_width, pixel_height) = (1797, 8, 8)\n",
+      "labels = (n_inputs) = (1797,)\n",
+      "X = (n_inputs, n_features) = (1797, 64)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# import necessary packages\n",
     "import numpy as np\n",
@@ -2561,11 +3120,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    },
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'tensorflow'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-15-b532db97c8ce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mto_categorical\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel_selection\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtrain_test_split\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# one-hot representation of labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mto_categorical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/keras/__init__.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0m__future__\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mabsolute_import\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mutils\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mactivations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mapplications\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/keras/utils/__init__.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdata_utils\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mio_utils\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mconv_utils\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# Globally-importable utils.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/keras/utils/conv_utils.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmoves\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mbackend\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mK\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/keras/backend/__init__.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     87\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0m_BACKEND\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'tensorflow'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     88\u001b[0m     \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Using TensorFlow backend.\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 89\u001b[0;31m     \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mtensorflow_backend\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     90\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m     \u001b[0;31m# Try and load external backend.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0m__future__\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mprint_function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mtensorflow\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtensorflow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframework\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mops\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mtf_ops\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtensorflow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraining\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmoving_averages\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'tensorflow'"
+     ]
+    }
+   ],
    "source": [
     "from keras.utils import to_categorical\n",
     "from sklearn.model_selection import train_test_split\n",
@@ -2594,9 +3175,7 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "import tensorflow as tf\n",
@@ -2742,9 +3321,7 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "epochs = 100\n",
@@ -2759,9 +3336,7 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "DNN_tf = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object)\n",
@@ -2784,9 +3359,7 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# optional\n",
@@ -2825,9 +3398,7 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# optional\n",
@@ -2851,9 +3422,7 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "conda install keras"
@@ -2869,9 +3438,7 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "pip3 install keras"
@@ -2887,9 +3454,7 @@
   {
    "cell_type": "code",
    "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "from keras.models import Sequential\n",
@@ -2912,9 +3477,7 @@
   {
    "cell_type": "code",
    "execution_count": 25,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "DNN_keras = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object)\n",
@@ -2937,9 +3500,7 @@
   {
    "cell_type": "code",
    "execution_count": 26,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# optional\n",
@@ -2976,7 +3537,25 @@
    ]
   }
  ],
- "metadata": {},
+ "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.0"
+  }
+ },
  "nbformat": 4,
  "nbformat_minor": 2
 }
diff --git a/doc/src/Splines/Splines.do.txt b/doc/src/Splines/Splines.do.txt
index a6eab5fd4..a4556fe71 100644
--- a/doc/src/Splines/Splines.do.txt
+++ b/doc/src/Splines/Splines.do.txt
@@ -613,6 +613,11 @@ it_array = np.array(guesses)
 pt.plot(it_array.T[0], it_array.T[1], "x-")
 !ec
 
+!split
+===== Conjugate gradient =====
+
+
+
 !split 
 ===== Revisiting our first homework =====
 
@@ -694,6 +699,9 @@ The Hessian matrix of $C(\beta)$ is given by
 !et
 This result implies that $C(\beta)$ is a convex function since the matrix $X^T X$ always is positive semi-definite.
 
+
+
+
 !split
 ===== Simple program =====
 
@@ -1367,6 +1375,10 @@ print("gamma_j after %d epochs: %g" % (n_epochs,gamma_j))
 
 
 
-
+!split
+=====  Program for stochastic gradient =====
+
+!split
+===== Momentum based methods =====
 
 

From 44ca73fe54887fcdba4ef549c908b2d680f0936f Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Sat, 6 Oct 2018 13:26:00 +0200
Subject: [PATCH 2/6] added code for stochastic gradient descent

---
 doc/src/Splines/Splines.do.txt | 77 ++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/doc/src/Splines/Splines.do.txt b/doc/src/Splines/Splines.do.txt
index a4556fe71..ef15d68f9 100644
--- a/doc/src/Splines/Splines.do.txt
+++ b/doc/src/Splines/Splines.do.txt
@@ -1378,6 +1378,83 @@ print("gamma_j after %d epochs: %g" % (n_epochs,gamma_j))
 !split
 =====  Program for stochastic gradient =====
 
+!bc pycod
+# Importing various packages
+from math import exp, sqrt
+from random import random, seed
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import SGDRegressor
+
+x = 2*np.random.rand(100,1)
+y = 4+3*x+np.random.randn(100,1)
+
+xb = np.c_[np.ones((100,1)), x]
+theta_linreg = np.linalg.inv(xb.T.dot(xb)).dot(xb.T).dot(y)
+print("Own inversion")
+print(theta_linreg)
+sgdreg = SGDRegressor(n_iter = 50, penalty=None, eta0=0.1)
+sgdreg.fit(x,y.ravel())
+print("sgdreg from scikit")
+print(sgdreg.intercept_, sgdreg.coef_)
+
+
+theta = np.random.randn(2,1)
+
+eta = 0.1
+Niterations = 1000
+m = 100
+
+for iter in range(Niterations):
+    gradients = 2.0/m*xb.T.dot(xb.dot(theta)-y)
+    theta -= eta*gradients
+print("theta frm own gd")
+print(theta)
+
+xnew = np.array([[0],[2]])
+xbnew = np.c_[np.ones((2,1)), xnew]
+ypredict = xbnew.dot(theta)
+ypredict2 = xbnew.dot(theta_linreg)
+
+
+n_epochs = 50
+t0, t1 = 5, 50
+m = 100
+def learning_schedule(t):
+    return t0/(t+t1)
+
+theta = np.random.randn(2,1)
+
+for epoch in range(n_epochs):
+    for i in range(m):
+        random_index = np.random.randint(m)
+        xi = xb[random_index:random_index+1]
+        yi = y[random_index:random_index+1]
+        gradients = 2 * xi.T.dot(xi.dot(theta)-yi)
+        eta = learning_schedule(epoch*m+i)
+        theta = theta - eta*gradients
+print("theta from own sdg")
+print(theta)
+
+
+
+
+
+
+plt.plot(xnew, ypredict, "r-")
+plt.plot(xnew, ypredict2, "b-")
+plt.plot(x, y ,'ro')
+plt.axis([0,2.0,0, 15.0])
+plt.xlabel(r'$x$')
+plt.ylabel(r'$y$')
+plt.title(r'Random numbers ')
+plt.show()
+
+!ec
+
+
+
+
 !split
 ===== Momentum based methods =====
 

From 7ab6bc250ec06ac64e67070e3c1e9a58ce5140a2 Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Sat, 6 Oct 2018 21:58:23 +0200
Subject: [PATCH 3/6] Added back CG method

---
 doc/pub/Splines/html/._Splines-bs000.html     | 140 ++--
 doc/pub/Splines/html/._Splines-bs001.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs002.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs003.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs004.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs005.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs006.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs007.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs008.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs009.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs010.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs011.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs012.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs013.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs014.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs015.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs016.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs017.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs018.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs019.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs020.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs021.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs022.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs023.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs024.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs025.html     | 138 ++--
 doc/pub/Splines/html/._Splines-bs026.html     | 170 ++--
 doc/pub/Splines/html/._Splines-bs027.html     | 170 ++--
 doc/pub/Splines/html/._Splines-bs028.html     | 162 ++--
 doc/pub/Splines/html/._Splines-bs029.html     | 153 ++--
 doc/pub/Splines/html/._Splines-bs030.html     | 179 ++--
 doc/pub/Splines/html/._Splines-bs031.html     | 204 +++--
 doc/pub/Splines/html/._Splines-bs032.html     | 173 ++--
 doc/pub/Splines/html/._Splines-bs033.html     | 201 +++--
 doc/pub/Splines/html/._Splines-bs034.html     | 210 +++--
 doc/pub/Splines/html/._Splines-bs035.html     | 198 +++--
 doc/pub/Splines/html/._Splines-bs036.html     | 189 +++--
 doc/pub/Splines/html/._Splines-bs037.html     | 188 +++--
 doc/pub/Splines/html/._Splines-bs038.html     | 168 ++--
 doc/pub/Splines/html/._Splines-bs039.html     | 159 ++--
 doc/pub/Splines/html/._Splines-bs040.html     | 181 ++--
 doc/pub/Splines/html/._Splines-bs041.html     | 192 +++--
 doc/pub/Splines/html/._Splines-bs042.html     | 174 ++--
 doc/pub/Splines/html/._Splines-bs043.html     | 179 ++--
 doc/pub/Splines/html/._Splines-bs044.html     | 181 ++--
 doc/pub/Splines/html/._Splines-bs045.html     | 162 ++--
 doc/pub/Splines/html/._Splines-bs046.html     | 164 ++--
 doc/pub/Splines/html/._Splines-bs047.html     | 171 ++--
 doc/pub/Splines/html/._Splines-bs048.html     | 171 ++--
 doc/pub/Splines/html/._Splines-bs049.html     | 180 ++--
 doc/pub/Splines/html/._Splines-bs050.html     | 183 +++--
 doc/pub/Splines/html/._Splines-bs051.html     | 202 ++---
 doc/pub/Splines/html/._Splines-bs052.html     |  65 +-
 doc/pub/Splines/html/Splines-bs.html          | 140 ++--
 doc/pub/Splines/html/Splines-reveal.html      | 485 ++++++++++-
 doc/pub/Splines/html/Splines-solarized.html   | 528 ++++++++++--
 doc/pub/Splines/html/Splines.html             | 528 ++++++++++--
 doc/pub/Splines/ipynb/Splines.ipynb           | 770 ++++++++++++++----
 .../Splines/ipynb/ipynb-Splines-src.tar.gz    | Bin 211 -> 209 bytes
 doc/pub/Splines/pdf/Splines-minted.pdf        | Bin 408608 -> 419239 bytes
 doc/src/Splines/Splines.do.txt                | 252 ++++++
 61 files changed, 7377 insertions(+), 3645 deletions(-)

diff --git a/doc/pub/Splines/html/._Splines-bs000.html b/doc/pub/Splines/html/._Splines-bs000.html
index 746f6012c..bece1e921 100644
--- a/doc/pub/Splines/html/._Splines-bs000.html
+++ b/doc/pub/Splines/html/._Splines-bs000.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -240,7 +272,7 @@ MathJax.Hub.Config({
 <center>[2] <b>Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University</b></center>
 <br>
 <p>
-<center><h4>Sep 27, 2018</h4></center> <!-- date -->
+<center><h4>Oct 6, 2018</h4></center> <!-- date -->
 <br>
 <p>
 
@@ -264,7 +296,7 @@ MathJax.Hub.Config({
   <li><a href="._Splines-bs008.html">9</a></li>
   <li><a href="._Splines-bs009.html">10</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs001.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs001.html b/doc/pub/Splines/html/._Splines-bs001.html
index 0be0809bf..5dcab7015 100644
--- a/doc/pub/Splines/html/._Splines-bs001.html
+++ b/doc/pub/Splines/html/._Splines-bs001.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -250,7 +282,7 @@ some approximative/numerical method to compute the minimum.
   <li><a href="._Splines-bs009.html">10</a></li>
   <li><a href="._Splines-bs010.html">11</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs002.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs002.html b/doc/pub/Splines/html/._Splines-bs002.html
index a2b7a1bba..d04d8f945 100644
--- a/doc/pub/Splines/html/._Splines-bs002.html
+++ b/doc/pub/Splines/html/._Splines-bs002.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -258,7 +290,7 @@ where \( \hat{\beta} \) are the weights we wish to extract from data, in our cas
   <li><a href="._Splines-bs010.html">11</a></li>
   <li><a href="._Splines-bs011.html">12</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs003.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs003.html b/doc/pub/Splines/html/._Splines-bs003.html
index 24da05b04..b39e9900e 100644
--- a/doc/pub/Splines/html/._Splines-bs003.html
+++ b/doc/pub/Splines/html/._Splines-bs003.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -263,7 +295,7 @@ This defines what is called  the Hessian matrix.
   <li><a href="._Splines-bs011.html">12</a></li>
   <li><a href="._Splines-bs012.html">13</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs004.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs004.html b/doc/pub/Splines/html/._Splines-bs004.html
index 46c8cb240..e63ef43ad 100644
--- a/doc/pub/Splines/html/._Splines-bs004.html
+++ b/doc/pub/Splines/html/._Splines-bs004.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -264,7 +296,7 @@ If we can compute these matrices, in particular the Hessian, the above is often
   <li><a href="._Splines-bs012.html">13</a></li>
   <li><a href="._Splines-bs013.html">14</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs005.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs005.html b/doc/pub/Splines/html/._Splines-bs005.html
index f84272d56..aaec6aa73 100644
--- a/doc/pub/Splines/html/._Splines-bs005.html
+++ b/doc/pub/Splines/html/._Splines-bs005.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -256,7 +288,7 @@ normally discourage the use of this method.
   <li><a href="._Splines-bs013.html">14</a></li>
   <li><a href="._Splines-bs014.html">15</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs006.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs006.html b/doc/pub/Splines/html/._Splines-bs006.html
index 65f34b9f3..1edaf8466 100644
--- a/doc/pub/Splines/html/._Splines-bs006.html
+++ b/doc/pub/Splines/html/._Splines-bs006.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -276,7 +308,7 @@ $$
   <li><a href="._Splines-bs014.html">15</a></li>
   <li><a href="._Splines-bs015.html">16</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs007.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs007.html b/doc/pub/Splines/html/._Splines-bs007.html
index e8f42dbcf..65a1cd9a2 100644
--- a/doc/pub/Splines/html/._Splines-bs007.html
+++ b/doc/pub/Splines/html/._Splines-bs007.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -259,7 +291,7 @@ vanishes, then Newton-Raphson may fail totally
   <li><a href="._Splines-bs015.html">16</a></li>
   <li><a href="._Splines-bs016.html">17</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs008.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs008.html b/doc/pub/Splines/html/._Splines-bs008.html
index 89082b3c4..e4b0d0150 100644
--- a/doc/pub/Splines/html/._Splines-bs008.html
+++ b/doc/pub/Splines/html/._Splines-bs008.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -297,7 +329,7 @@ more than two non-linear equations. In our case, the Jacobian matrix is given by
   <li><a href="._Splines-bs016.html">17</a></li>
   <li><a href="._Splines-bs017.html">18</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs009.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs009.html b/doc/pub/Splines/html/._Splines-bs009.html
index 7efb3aba6..95b7b9fde 100644
--- a/doc/pub/Splines/html/._Splines-bs009.html
+++ b/doc/pub/Splines/html/._Splines-bs009.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -267,7 +299,7 @@ we are always moving towards smaller function values, i.e a minimum.
   <li><a href="._Splines-bs017.html">18</a></li>
   <li><a href="._Splines-bs018.html">19</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs010.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs010.html b/doc/pub/Splines/html/._Splines-bs010.html
index 14f73c7cf..930254831 100644
--- a/doc/pub/Splines/html/._Splines-bs010.html
+++ b/doc/pub/Splines/html/._Splines-bs010.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -263,7 +295,7 @@ the learning rate within the context of Machine Learning.
   <li><a href="._Splines-bs018.html">19</a></li>
   <li><a href="._Splines-bs019.html">20</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs011.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs011.html b/doc/pub/Splines/html/._Splines-bs011.html
index 5ca45906b..a2d29ef4d 100644
--- a/doc/pub/Splines/html/._Splines-bs011.html
+++ b/doc/pub/Splines/html/._Splines-bs011.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -270,7 +302,7 @@ Note that the gradient is a function of \( \mathbf{x} =
   <li><a href="._Splines-bs019.html">20</a></li>
   <li><a href="._Splines-bs020.html">21</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs012.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs012.html b/doc/pub/Splines/html/._Splines-bs012.html
index f841381a7..de3759975 100644
--- a/doc/pub/Splines/html/._Splines-bs012.html
+++ b/doc/pub/Splines/html/._Splines-bs012.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -263,7 +295,7 @@ randomness. One such method is that of Stochastic Gradient Descent
   <li><a href="._Splines-bs020.html">21</a></li>
   <li><a href="._Splines-bs021.html">22</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs013.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs013.html b/doc/pub/Splines/html/._Splines-bs013.html
index 0bfe735b0..288107e02 100644
--- a/doc/pub/Splines/html/._Splines-bs013.html
+++ b/doc/pub/Splines/html/._Splines-bs013.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -264,7 +296,7 @@ regular polygons (triangles, rectangles, pentagons, etc...).
   <li><a href="._Splines-bs021.html">22</a></li>
   <li><a href="._Splines-bs022.html">23</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs014.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs014.html b/doc/pub/Splines/html/._Splines-bs014.html
index e0e7315fe..5e10bd7e7 100644
--- a/doc/pub/Splines/html/._Splines-bs014.html
+++ b/doc/pub/Splines/html/._Splines-bs014.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -252,7 +284,7 @@ MathJax.Hub.Config({
   <li><a href="._Splines-bs022.html">23</a></li>
   <li><a href="._Splines-bs023.html">24</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs015.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs015.html b/doc/pub/Splines/html/._Splines-bs015.html
index ef04f60dd..91adb73aa 100644
--- a/doc/pub/Splines/html/._Splines-bs015.html
+++ b/doc/pub/Splines/html/._Splines-bs015.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -288,7 +320,7 @@ This condition is particularly useful since it gives us an procedure for determi
   <li><a href="._Splines-bs023.html">24</a></li>
   <li><a href="._Splines-bs024.html">25</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs016.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs016.html b/doc/pub/Splines/html/._Splines-bs016.html
index 456055b39..707c47a6c 100644
--- a/doc/pub/Splines/html/._Splines-bs016.html
+++ b/doc/pub/Splines/html/._Splines-bs016.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -275,7 +307,7 @@ This result means that if we know that the cost/loss function is convex and we a
   <li><a href="._Splines-bs024.html">25</a></li>
   <li><a href="._Splines-bs025.html">26</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs017.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs017.html b/doc/pub/Splines/html/._Splines-bs017.html
index cd266d02f..efe5d542e 100644
--- a/doc/pub/Splines/html/._Splines-bs017.html
+++ b/doc/pub/Splines/html/._Splines-bs017.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -271,7 +303,7 @@ Using the definition of convexity, try to show that a function satisfying the pr
   <li><a href="._Splines-bs025.html">26</a></li>
   <li><a href="._Splines-bs026.html">27</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs018.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs018.html b/doc/pub/Splines/html/._Splines-bs018.html
index 35a3160a3..d6f43e6d8 100644
--- a/doc/pub/Splines/html/._Splines-bs018.html
+++ b/doc/pub/Splines/html/._Splines-bs018.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -280,7 +312,7 @@ When we have found the exact solution, \( \hat{r}=0 \).
   <li><a href="._Splines-bs026.html">27</a></li>
   <li><a href="._Splines-bs027.html">28</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs019.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs019.html b/doc/pub/Splines/html/._Splines-bs019.html
index 10f59d0e6..2664f2e41 100644
--- a/doc/pub/Splines/html/._Splines-bs019.html
+++ b/doc/pub/Splines/html/._Splines-bs019.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -261,7 +293,7 @@ symmetric.  This defines also the Hessian and we want it to be  positive definit
   <li><a href="._Splines-bs027.html">28</a></li>
   <li><a href="._Splines-bs028.html">29</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs020.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs020.html b/doc/pub/Splines/html/._Splines-bs020.html
index ed4572c77..d51c26820 100644
--- a/doc/pub/Splines/html/._Splines-bs020.html
+++ b/doc/pub/Splines/html/._Splines-bs020.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -267,7 +299,7 @@ instead.
   <li><a href="._Splines-bs028.html">29</a></li>
   <li><a href="._Splines-bs029.html">30</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs021.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs021.html b/doc/pub/Splines/html/._Splines-bs021.html
index 7380b4423..d41a12c70 100644
--- a/doc/pub/Splines/html/._Splines-bs021.html
+++ b/doc/pub/Splines/html/._Splines-bs021.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -275,7 +307,7 @@ and
   <li><a href="._Splines-bs029.html">30</a></li>
   <li><a href="._Splines-bs030.html">31</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs022.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs022.html b/doc/pub/Splines/html/._Splines-bs022.html
index 3a4092527..da6752d42 100644
--- a/doc/pub/Splines/html/._Splines-bs022.html
+++ b/doc/pub/Splines/html/._Splines-bs022.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -288,7 +320,7 @@ $$
   <li><a href="._Splines-bs030.html">31</a></li>
   <li><a href="._Splines-bs031.html">32</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs023.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs023.html b/doc/pub/Splines/html/._Splines-bs023.html
index 8e43704ec..3d49a5bef 100644
--- a/doc/pub/Splines/html/._Splines-bs023.html
+++ b/doc/pub/Splines/html/._Splines-bs023.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -285,7 +317,7 @@ MathJax.Hub.Config({
   <li><a href="._Splines-bs031.html">32</a></li>
   <li><a href="._Splines-bs032.html">33</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs024.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs024.html b/doc/pub/Splines/html/._Splines-bs024.html
index efedabd77..62b53c6d0 100644
--- a/doc/pub/Splines/html/._Splines-bs024.html
+++ b/doc/pub/Splines/html/._Splines-bs024.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -281,7 +313,7 @@ MathJax.Hub.Config({
   <li><a href="._Splines-bs032.html">33</a></li>
   <li><a href="._Splines-bs033.html">34</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs025.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs025.html b/doc/pub/Splines/html/._Splines-bs025.html
index 22abad618..9face255c 100644
--- a/doc/pub/Splines/html/._Splines-bs025.html
+++ b/doc/pub/Splines/html/._Splines-bs025.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -313,7 +345,7 @@ pt<span style="color: #666666">.</span>plot(it_array<span style="color: #666666"
   <li><a href="._Splines-bs033.html">34</a></li>
   <li><a href="._Splines-bs034.html">35</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs026.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs026.html b/doc/pub/Splines/html/._Splines-bs026.html
index 64d077f45..94a0a1fc8 100644
--- a/doc/pub/Splines/html/._Splines-bs026.html
+++ b/doc/pub/Splines/html/._Splines-bs026.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,37 +251,9 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0026"></a>
-<!-- !split  -->
+<!-- !split -->
 
-<h2 id="___sec25" class="anchor">Revisiting our first homework </h2>
-
-<p>
-We will use linear regression as a case study for the gradient descent
-methods. Linear regression is a great test case for the gradient
-descent methods discussed in the lectures since it has several
-desirable properties such as:
-
-<ol>
-<li> An analytical solution (recall homework set 1).</li>
-<li> The gradient can be computed analytically.</li>
-<li> The cost function is convex which guarantees that gradient descent converges for small enough learning rates</li>
-</ol>
-
-We revisit the example from homework set 1 where we had 
-$$
-y_i = 5x_i^2 + 0.1\xi_i, \ i=1,\cdots,100
-$$
-
-with \( x_i \in [0,1]  \) chosen randomly with a uniform distribution. Additionally \( \xi_i \) represents stochastic noise chosen according to a normal distribution \( \cal {N}(0,1) \). 
-The linear regression model is given by 
-$$
-h_\beta(x) = \hat{y} = \beta_0 + \beta_1 x,
-$$
-
-such that 
-$$
-\hat{y}_i = \beta_0 + \beta_1 x_i.
-$$
+<h2 id="___sec25" class="anchor">Conjugate gradient </h2>
 
 <p>
 <p>
@@ -277,7 +281,7 @@ $$
   <li><a href="._Splines-bs034.html">35</a></li>
   <li><a href="._Splines-bs035.html">36</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs027.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs027.html b/doc/pub/Splines/html/._Splines-bs027.html
index 19087e41d..b5ed4f3ab 100644
--- a/doc/pub/Splines/html/._Splines-bs027.html
+++ b/doc/pub/Splines/html/._Splines-bs027.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,27 +253,35 @@ MathJax.Hub.Config({
 <a name="part0027"></a>
 <!-- !split  -->
 
-<h2 id="___sec26" class="anchor">Gradient descent example </h2>
+<h2 id="___sec26" class="anchor">Revisiting our first homework </h2>
 
 <p>
-Let \( \mathbf{y} = (y_1,\cdots,y_n)^T \), \( \mathbf{\hat{y}} = (\hat{y}_1,\cdots,\hat{y}_n)^T \) and \( \beta = (\beta_0, \beta_1)^T \)
+We will use linear regression as a case study for the gradient descent
+methods. Linear regression is a great test case for the gradient
+descent methods discussed in the lectures since it has several
+desirable properties such as:
 
-<p>
-It is convenient to write \( \mathbf{\hat{y}} = X\beta \) where \( X \in \mathbb{R}^{100 \times 2}  \) is the design matrix given by
+<ol>
+<li> An analytical solution (recall homework set 1).</li>
+<li> The gradient can be computed analytically.</li>
+<li> The cost function is convex which guarantees that gradient descent converges for small enough learning rates</li>
+</ol>
+
+We revisit the example from homework set 1 where we had 
 $$
-X \equiv \begin{bmatrix}
-1 &amp; x_1  \\
-\vdots &amp; \vdots  \\
-1 &amp; x_{100} &amp;  \\
-\end{bmatrix}.
+y_i = 5x_i^2 + 0.1\xi_i, \ i=1,\cdots,100
 $$
 
-The loss function is given by 
+with \( x_i \in [0,1]  \) chosen randomly with a uniform distribution. Additionally \( \xi_i \) represents stochastic noise chosen according to a normal distribution \( \cal {N}(0,1) \). 
+The linear regression model is given by 
 $$
-C(\beta) = ||X\beta-\mathbf{y}||^2 = ||X\beta||^2 - 2 \mathbf{y}^T X\beta + ||\mathbf{y}||^2 = \sum_{i=1}^{100} (\beta_0 + \beta_1 x_i)^2 - 2 y_i (\beta_0 + \beta_1 x_i) + y_i^2 
+h_\beta(x) = \hat{y} = \beta_0 + \beta_1 x,
 $$
 
-and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
+such that 
+$$
+\hat{y}_i = \beta_0 + \beta_1 x_i.
+$$
 
 <p>
 <p>
@@ -269,7 +309,7 @@ and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
   <li><a href="._Splines-bs035.html">36</a></li>
   <li><a href="._Splines-bs036.html">37</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs028.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs028.html b/doc/pub/Splines/html/._Splines-bs028.html
index 37718c1bd..9a3ebf016 100644
--- a/doc/pub/Splines/html/._Splines-bs028.html
+++ b/doc/pub/Splines/html/._Splines-bs028.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,19 +251,29 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0028"></a>
-<!-- !split -->
+<!-- !split  -->
 
-<h2 id="___sec27" class="anchor">The derivative of the cost/loss function </h2>
+<h2 id="___sec27" class="anchor">Gradient descent example </h2>
 
 <p>
-Computing \( \partial C(\beta) / \partial \beta_0 \) and \( \partial C(\beta) / \partial \beta_1 \) we can show  that the gradient can be written as
+Let \( \mathbf{y} = (y_1,\cdots,y_n)^T \), \( \mathbf{\hat{y}} = (\hat{y}_1,\cdots,\hat{y}_n)^T \) and \( \beta = (\beta_0, \beta_1)^T \)
+
+<p>
+It is convenient to write \( \mathbf{\hat{y}} = X\beta \) where \( X \in \mathbb{R}^{100 \times 2}  \) is the design matrix given by
 $$
-\nabla_{\beta} C(\beta) = (\partial C(\beta) / \partial \beta_0, \partial C(\beta) / \partial \beta_1)^T = 2\begin{bmatrix} \sum_{i=1}^{100} \left(\beta_0+\beta_1x_i-y_i\right) \\
-\sum_{i=1}^{100}\left( x_i (\beta_0+\beta_1x_i)-y_ix_i\right) \\
-\end{bmatrix} = 2X^T(X\beta - \mathbf{y}), 
+X \equiv \begin{bmatrix}
+1 &amp; x_1  \\
+\vdots &amp; \vdots  \\
+1 &amp; x_{100} &amp;  \\
+\end{bmatrix}.
 $$
 
-where \( X \) is the design matrix defined above.
+The loss function is given by 
+$$
+C(\beta) = ||X\beta-\mathbf{y}||^2 = ||X\beta||^2 - 2 \mathbf{y}^T X\beta + ||\mathbf{y}||^2 = \sum_{i=1}^{100} (\beta_0 + \beta_1 x_i)^2 - 2 y_i (\beta_0 + \beta_1 x_i) + y_i^2 
+$$
+
+and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
 
 <p>
 <p>
@@ -259,7 +301,7 @@ where \( X \) is the design matrix defined above.
   <li><a href="._Splines-bs036.html">37</a></li>
   <li><a href="._Splines-bs037.html">38</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs029.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs029.html b/doc/pub/Splines/html/._Splines-bs029.html
index 949dcee6d..669f6e55b 100644
--- a/doc/pub/Splines/html/._Splines-bs029.html
+++ b/doc/pub/Splines/html/._Splines-bs029.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,16 +253,17 @@ MathJax.Hub.Config({
 <a name="part0029"></a>
 <!-- !split -->
 
-<h2 id="___sec28" class="anchor">The Hessian matrix </h2>
-The Hessian matrix of \( C(\beta) \) is given by 
+<h2 id="___sec28" class="anchor">The derivative of the cost/loss function </h2>
+
+<p>
+Computing \( \partial C(\beta) / \partial \beta_0 \) and \( \partial C(\beta) / \partial \beta_1 \) we can show  that the gradient can be written as
 $$
-\hat{H} \equiv \begin{bmatrix}
-\frac{\partial^2 C(\beta)}{\partial \beta_0^2} &amp; \frac{\partial^2 C(\beta)}{\partial \beta_0 \partial \beta_1}  \\
-\frac{\partial^2 C(\beta)}{\partial \beta_0 \partial \beta_1} &amp; \frac{\partial^2 C(\beta)}{\partial \beta_1^2} &amp;  \\
-\end{bmatrix} = 2X^T X.
+\nabla_{\beta} C(\beta) = (\partial C(\beta) / \partial \beta_0, \partial C(\beta) / \partial \beta_1)^T = 2\begin{bmatrix} \sum_{i=1}^{100} \left(\beta_0+\beta_1x_i-y_i\right) \\
+\sum_{i=1}^{100}\left( x_i (\beta_0+\beta_1x_i)-y_ix_i\right) \\
+\end{bmatrix} = 2X^T(X\beta - \mathbf{y}), 
 $$
 
-This result implies that \( C(\beta) \) is a convex function since the matrix \( X^T X \) always is positive semi-definite.
+where \( X \) is the design matrix defined above.
 
 <p>
 <p>
@@ -258,7 +291,7 @@ This result implies that \( C(\beta) \) is a convex function since the matrix \(
   <li><a href="._Splines-bs037.html">38</a></li>
   <li><a href="._Splines-bs038.html">39</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs030.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs030.html b/doc/pub/Splines/html/._Splines-bs030.html
index 93dbfa54a..9c1875db6 100644
--- a/doc/pub/Splines/html/._Splines-bs030.html
+++ b/doc/pub/Splines/html/._Splines-bs030.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,44 +253,17 @@ MathJax.Hub.Config({
 <a name="part0030"></a>
 <!-- !split -->
 
-<h2 id="___sec29" class="anchor">Simple program </h2>
-
-<p>
-We can now write a program that minimizes \( C(\beta) \) using the gradient descent method with a constant learning rate \( \gamma \) according to 
+<h2 id="___sec29" class="anchor">The Hessian matrix </h2>
+The Hessian matrix of \( C(\beta) \) is given by 
 $$
-\beta_{k+1} = \beta_k - \gamma \nabla_\beta C(\beta_k), \ k=0,1,\cdots 
+\hat{H} \equiv \begin{bmatrix}
+\frac{\partial^2 C(\beta)}{\partial \beta_0^2} &amp; \frac{\partial^2 C(\beta)}{\partial \beta_0 \partial \beta_1}  \\
+\frac{\partial^2 C(\beta)}{\partial \beta_0 \partial \beta_1} &amp; \frac{\partial^2 C(\beta)}{\partial \beta_1^2} &amp;  \\
+\end{bmatrix} = 2X^T X.
 $$
 
-<p>
-We can use the expression we computed for the gradient and let use a
-\( \beta_0 \) be chosen randomly and let \( \gamma = 0.001 \). Stop iterating
-when \( ||\nabla_\beta C(\beta_k) || \leq \epsilon = 10^{-8} \).
+This result implies that \( C(\beta) \) is a convex function since the matrix \( X^T X \) always is positive semi-definite.
 
-<p>
-And finally we can compare our solution for \( \beta \) with the analytic result given by 
-\( \beta= (X^TX)^{-1} X^T \mathbf{y} \).
-<p>
-
-<!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
-
-<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
-<span style="color: #BA2121; font-style: italic">The following setup is just a suggestion, feel free to write it the way you like.</span>
-<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
-
-<span style="color: #408080; font-style: italic">#Setup problem described in the exercise</span>
-N  <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#Nr of datapoints</span>
-M  <span style="color: #666666">=</span> <span style="color: #666666">2</span> <span style="color: #408080; font-style: italic">#Nr of features</span>
-x  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(N) <span style="color: #408080; font-style: italic">#Uniformly generated x-values in [0,1]</span>
-y  <span style="color: #666666">=</span> <span style="color: #666666">5*</span>x<span style="color: #666666">**2</span> <span style="color: #666666">+</span> <span style="color: #666666">0.1*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(N)
-X  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones(N),x] <span style="color: #408080; font-style: italic">#Construct design matrix</span>
-
-<span style="color: #408080; font-style: italic">#Compute beta according to normal equations to compare with GD solution</span>
-Xt_X_inv <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,X))
-Xt_y     <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>transpose(),y)
-beta_NE <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(Xt_X_inv,Xt_y)
-<span style="color: #008000; font-weight: bold">print</span>(beta_NE)
-</pre></div>
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -285,7 +290,7 @@ beta_NE <span style="color: #666666">=</span> np<span style="color: #666666">.</
   <li><a href="._Splines-bs038.html">39</a></li>
   <li><a href="._Splines-bs039.html">40</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs031.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs031.html b/doc/pub/Splines/html/._Splines-bs031.html
index 25032ca76..7478f48c2 100644
--- a/doc/pub/Splines/html/._Splines-bs031.html
+++ b/doc/pub/Splines/html/._Splines-bs031.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,51 +253,43 @@ MathJax.Hub.Config({
 <a name="part0031"></a>
 <!-- !split -->
 
-<h2 id="___sec30" class="anchor">Gradient Descent Example </h2>
+<h2 id="___sec30" class="anchor">Simple program </h2>
 
 <p>
-Another simple example is here
+We can now write a program that minimizes \( C(\beta) \) using the gradient descent method with a constant learning rate \( \gamma \) according to 
+$$
+\beta_{k+1} = \beta_k - \gamma \nabla_\beta C(\beta_k), \ k=0,1,\cdots 
+$$
+
+<p>
+We can use the expression we computed for the gradient and let use a
+\( \beta_0 \) be chosen randomly and let \( \gamma = 0.001 \). Stop iterating
+when \( ||\nabla_\beta C(\beta_k) || \leq \epsilon = 10^{-8} \).
+
+<p>
+And finally we can compare our solution for \( \beta \) with the analytic result given by 
+\( \beta= (X^TX)^{-1} X^T \mathbf{y} \).
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #408080; font-style: italic"># Importing various packages</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">random</span> <span style="color: #008000; font-weight: bold">import</span> random, seed
-<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
-<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">mpl_toolkits.mplot3d</span> <span style="color: #008000; font-weight: bold">import</span> Axes3D
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">matplotlib</span> <span style="color: #008000; font-weight: bold">import</span> cm
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">matplotlib.ticker</span> <span style="color: #008000; font-weight: bold">import</span> LinearLocator, FormatStrFormatter
-<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">sys</span>
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 
-x <span style="color: #666666">=</span> <span style="color: #666666">2*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
-y <span style="color: #666666">=</span> <span style="color: #666666">4+3*</span>x<span style="color: #666666">+</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
+<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
+<span style="color: #BA2121; font-style: italic">The following setup is just a suggestion, feel free to write it the way you like.</span>
+<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
 
-xb <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)), x]
-beta_linreg <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb))<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>T)<span style="color: #666666">.</span>dot(y)
-<span style="color: #008000; font-weight: bold">print</span>(beta_linreg)
-beta <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)
+<span style="color: #408080; font-style: italic">#Setup problem described in the exercise</span>
+N  <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#Nr of datapoints</span>
+M  <span style="color: #666666">=</span> <span style="color: #666666">2</span> <span style="color: #408080; font-style: italic">#Nr of features</span>
+x  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(N) <span style="color: #408080; font-style: italic">#Uniformly generated x-values in [0,1]</span>
+y  <span style="color: #666666">=</span> <span style="color: #666666">5*</span>x<span style="color: #666666">**2</span> <span style="color: #666666">+</span> <span style="color: #666666">0.1*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(N)
+X  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones(N),x] <span style="color: #408080; font-style: italic">#Construct design matrix</span>
 
-eta <span style="color: #666666">=</span> <span style="color: #666666">0.1</span>
-Niterations <span style="color: #666666">=</span> <span style="color: #666666">1000</span>
-m <span style="color: #666666">=</span> <span style="color: #666666">100</span>
-
-<span style="color: #008000; font-weight: bold">for</span> <span style="color: #008000">iter</span> <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(Niterations):
-    gradients <span style="color: #666666">=</span> <span style="color: #666666">2.0/</span>m<span style="color: #666666">*</span>xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>dot(beta)<span style="color: #666666">-</span>y)
-    beta <span style="color: #666666">-=</span> eta<span style="color: #666666">*</span>gradients
-
-<span style="color: #008000; font-weight: bold">print</span>(beta)
-xnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([[<span style="color: #666666">0</span>],[<span style="color: #666666">2</span>]])
-xbnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)), xnew]
-ypredict <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(beta)
-ypredict2 <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(beta_linreg)
-plt<span style="color: #666666">.</span>plot(xnew, ypredict, <span style="color: #BA2121">&quot;r-&quot;</span>)
-plt<span style="color: #666666">.</span>plot(xnew, ypredict2, <span style="color: #BA2121">&quot;b-&quot;</span>)
-plt<span style="color: #666666">.</span>plot(x, y ,<span style="color: #BA2121">&#39;ro&#39;</span>)
-plt<span style="color: #666666">.</span>axis([<span style="color: #666666">0</span>,<span style="color: #666666">2.0</span>,<span style="color: #666666">0</span>, <span style="color: #666666">15.0</span>])
-plt<span style="color: #666666">.</span>xlabel(<span style="color: #BA2121">r&#39;$x$&#39;</span>)
-plt<span style="color: #666666">.</span>ylabel(<span style="color: #BA2121">r&#39;$y$&#39;</span>)
-plt<span style="color: #666666">.</span>title(<span style="color: #BA2121">r&#39;Gradient descent example&#39;</span>)
-plt<span style="color: #666666">.</span>show()
+<span style="color: #408080; font-style: italic">#Compute beta according to normal equations to compare with GD solution</span>
+Xt_X_inv <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,X))
+Xt_y     <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>transpose(),y)
+beta_NE <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(Xt_X_inv,Xt_y)
+<span style="color: #008000; font-weight: bold">print</span>(beta_NE)
 </pre></div>
 <p>
 <p>
@@ -293,7 +317,7 @@ plt<span style="color: #666666">.</span>show()
   <li><a href="._Splines-bs039.html">40</a></li>
   <li><a href="._Splines-bs040.html">41</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs032.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs032.html b/doc/pub/Splines/html/._Splines-bs032.html
index 7a6653fb1..bf241c7bb 100644
--- a/doc/pub/Splines/html/._Splines-bs032.html
+++ b/doc/pub/Splines/html/._Splines-bs032.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,8 +253,10 @@ MathJax.Hub.Config({
 <a name="part0032"></a>
 <!-- !split -->
 
-<h2 id="___sec31" class="anchor">And a corresponding example using <b>scikit-learn</b> </h2>
+<h2 id="___sec31" class="anchor">Gradient Descent Example </h2>
 
+<p>
+Another simple example is here
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
@@ -230,7 +264,10 @@ MathJax.Hub.Config({
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">random</span> <span style="color: #008000; font-weight: bold">import</span> random, seed
 <span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">sklearn.linear_model</span> <span style="color: #008000; font-weight: bold">import</span> SGDRegressor
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">mpl_toolkits.mplot3d</span> <span style="color: #008000; font-weight: bold">import</span> Axes3D
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">matplotlib</span> <span style="color: #008000; font-weight: bold">import</span> cm
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">matplotlib.ticker</span> <span style="color: #008000; font-weight: bold">import</span> LinearLocator, FormatStrFormatter
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">sys</span>
 
 x <span style="color: #666666">=</span> <span style="color: #666666">2*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
 y <span style="color: #666666">=</span> <span style="color: #666666">4+3*</span>x<span style="color: #666666">+</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
@@ -238,9 +275,29 @@ y <span style="color: #666666">=</span> <span style="color: #666666">4+3*</span>
 xb <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)), x]
 beta_linreg <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb))<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>T)<span style="color: #666666">.</span>dot(y)
 <span style="color: #008000; font-weight: bold">print</span>(beta_linreg)
-sgdreg <span style="color: #666666">=</span> SGDRegressor(n_iter <span style="color: #666666">=</span> <span style="color: #666666">50</span>, penalty<span style="color: #666666">=</span><span style="color: #008000">None</span>, eta0<span style="color: #666666">=0.1</span>)
-sgdreg<span style="color: #666666">.</span>fit(x,y<span style="color: #666666">.</span>ravel())
-<span style="color: #008000; font-weight: bold">print</span>(sgdreg<span style="color: #666666">.</span>intercept_, sgdreg<span style="color: #666666">.</span>coef_)
+beta <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)
+
+eta <span style="color: #666666">=</span> <span style="color: #666666">0.1</span>
+Niterations <span style="color: #666666">=</span> <span style="color: #666666">1000</span>
+m <span style="color: #666666">=</span> <span style="color: #666666">100</span>
+
+<span style="color: #008000; font-weight: bold">for</span> <span style="color: #008000">iter</span> <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(Niterations):
+    gradients <span style="color: #666666">=</span> <span style="color: #666666">2.0/</span>m<span style="color: #666666">*</span>xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>dot(beta)<span style="color: #666666">-</span>y)
+    beta <span style="color: #666666">-=</span> eta<span style="color: #666666">*</span>gradients
+
+<span style="color: #008000; font-weight: bold">print</span>(beta)
+xnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([[<span style="color: #666666">0</span>],[<span style="color: #666666">2</span>]])
+xbnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)), xnew]
+ypredict <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(beta)
+ypredict2 <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(beta_linreg)
+plt<span style="color: #666666">.</span>plot(xnew, ypredict, <span style="color: #BA2121">&quot;r-&quot;</span>)
+plt<span style="color: #666666">.</span>plot(xnew, ypredict2, <span style="color: #BA2121">&quot;b-&quot;</span>)
+plt<span style="color: #666666">.</span>plot(x, y ,<span style="color: #BA2121">&#39;ro&#39;</span>)
+plt<span style="color: #666666">.</span>axis([<span style="color: #666666">0</span>,<span style="color: #666666">2.0</span>,<span style="color: #666666">0</span>, <span style="color: #666666">15.0</span>])
+plt<span style="color: #666666">.</span>xlabel(<span style="color: #BA2121">r&#39;$x$&#39;</span>)
+plt<span style="color: #666666">.</span>ylabel(<span style="color: #BA2121">r&#39;$y$&#39;</span>)
+plt<span style="color: #666666">.</span>title(<span style="color: #BA2121">r&#39;Gradient descent example&#39;</span>)
+plt<span style="color: #666666">.</span>show()
 </pre></div>
 <p>
 <p>
@@ -268,7 +325,7 @@ sgdreg<span style="color: #666666">.</span>fit(x,y<span style="color: #666666">.
   <li><a href="._Splines-bs040.html">41</a></li>
   <li><a href="._Splines-bs041.html">42</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs033.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs033.html b/doc/pub/Splines/html/._Splines-bs033.html
index b354565cd..73cfcff08 100644
--- a/doc/pub/Splines/html/._Splines-bs033.html
+++ b/doc/pub/Splines/html/._Splines-bs033.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,61 +251,28 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0033"></a>
-<!-- !split  -->
+<!-- !split -->
 
-<h2 id="___sec32" class="anchor">Gradient descent and Ridge </h2>
-
-<p>
-We have also discussed Ridge regression where the loss function contains a regularized given by the \( L_2 \) norm of \( \beta \), 
-$$
-C_{\text{ridge}}(\beta) = ||X\beta -\mathbf{y}||^2 + \lambda ||\beta||^2, \ \lambda \geq 0.
-$$
-
-<p>
-In order to minimize \( C_{\text{ridge}}(\beta) \) using GD we only have adjust the gradient as follows 
-$$
-\nabla_\beta C_{\text{ridge}}(\beta)  = 2\begin{bmatrix} \sum_{i=1}^{100} \left(\beta_0+\beta_1x_i-y_i\right) \\
-\sum_{i=1}^{100}\left( x_i (\beta_0+\beta_1x_i)-y_ix_i\right) \\
-\end{bmatrix} + 2\lambda\begin{bmatrix} \beta_0 \\ \beta_1\end{bmatrix} = 2 (X^T(X\beta - \mathbf{y})+\lambda \beta).
-$$
-
-<p>
-We can now extend our program to minimize \( C_{\text{ridge}}(\beta) \) using gradient descent and compare with the analytical solution given by 
-$$
-\beta_{\text{ridge}} = \left(X^T X + \lambda I_{2 \times 2} \right)^{-1} X^T \mathbf{y},
-$$
-
-for \( \lambda = {0,1,10,50,100} \) (\( \lambda = 0 \) corresponds to ordinary least squares). 
-We can then compute \( ||\beta_{\text{ridge}}|| \) for each \( \lambda \).
+<h2 id="___sec32" class="anchor">And a corresponding example using <b>scikit-learn</b> </h2>
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #408080; font-style: italic"># Importing various packages</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">random</span> <span style="color: #008000; font-weight: bold">import</span> random, seed
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">sklearn.linear_model</span> <span style="color: #008000; font-weight: bold">import</span> SGDRegressor
 
-<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
-<span style="color: #BA2121; font-style: italic">The following setup is just a suggestion, feel free to write it the way you like.</span>
-<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
+x <span style="color: #666666">=</span> <span style="color: #666666">2*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
+y <span style="color: #666666">=</span> <span style="color: #666666">4+3*</span>x<span style="color: #666666">+</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
 
-<span style="color: #408080; font-style: italic">#Setup problem described in the exercise</span>
-N  <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#Nr of datapoints</span>
-M  <span style="color: #666666">=</span> <span style="color: #666666">2</span>   <span style="color: #408080; font-style: italic">#Nr of features</span>
-x  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(N)
-y  <span style="color: #666666">=</span> <span style="color: #666666">5*</span>x<span style="color: #666666">**2</span> <span style="color: #666666">+</span> <span style="color: #666666">0.1*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(N)
-
-
-<span style="color: #408080; font-style: italic">#Compute analytic beta for Ridge regression </span>
-X    <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones(N),x]
-XT_X <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,X)
-
-l  <span style="color: #666666">=</span> <span style="color: #666666">0.1</span> <span style="color: #408080; font-style: italic">#Ridge parameter lambda</span>
-Id <span style="color: #666666">=</span> np<span style="color: #666666">.</span>eye(XT_X<span style="color: #666666">.</span>shape[<span style="color: #666666">0</span>])
-
-Z <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(XT_X<span style="color: #666666">+</span>l<span style="color: #666666">*</span>Id)
-beta_ridge <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(Z,np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,y))
-
-<span style="color: #008000; font-weight: bold">print</span>(beta_ridge)
-<span style="color: #008000; font-weight: bold">print</span>(np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>norm(beta_ridge)) <span style="color: #408080; font-style: italic">#||beta||</span>
+xb <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)), x]
+beta_linreg <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb))<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>T)<span style="color: #666666">.</span>dot(y)
+<span style="color: #008000; font-weight: bold">print</span>(beta_linreg)
+sgdreg <span style="color: #666666">=</span> SGDRegressor(n_iter <span style="color: #666666">=</span> <span style="color: #666666">50</span>, penalty<span style="color: #666666">=</span><span style="color: #008000">None</span>, eta0<span style="color: #666666">=0.1</span>)
+sgdreg<span style="color: #666666">.</span>fit(x,y<span style="color: #666666">.</span>ravel())
+<span style="color: #008000; font-weight: bold">print</span>(sgdreg<span style="color: #666666">.</span>intercept_, sgdreg<span style="color: #666666">.</span>coef_)
 </pre></div>
 <p>
 <p>
@@ -301,7 +300,7 @@ beta_ridge <span style="color: #666666">=</span> np<span style="color: #666666">
   <li><a href="._Splines-bs041.html">42</a></li>
   <li><a href="._Splines-bs042.html">43</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs034.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs034.html b/doc/pub/Splines/html/._Splines-bs034.html
index fa85226ed..8181deb1a 100644
--- a/doc/pub/Splines/html/._Splines-bs034.html
+++ b/doc/pub/Splines/html/._Splines-bs034.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,59 +251,61 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0034"></a>
-<!-- !split -->
+<!-- !split  -->
 
-<h2 id="___sec33" class="anchor">Automatic differentiation </h2>
-Python has tools for so-called <b>automatic differentiation</b>.
-Consider the following example
+<h2 id="___sec33" class="anchor">Gradient descent and Ridge </h2>
+
+<p>
+We have also discussed Ridge regression where the loss function contains a regularized given by the \( L_2 \) norm of \( \beta \), 
 $$
-f(x) = \sin\left(2\pi x + x^2\right)
+C_{\text{ridge}}(\beta) = ||X\beta -\mathbf{y}||^2 + \lambda ||\beta||^2, \ \lambda \geq 0.
 $$
 
-which has the following derivative
+<p>
+In order to minimize \( C_{\text{ridge}}(\beta) \) using GD we only have adjust the gradient as follows 
 $$
-f'(x) = \cos\left(2\pi x + x^2\right)\left(2\pi + 2x\right) 
+\nabla_\beta C_{\text{ridge}}(\beta)  = 2\begin{bmatrix} \sum_{i=1}^{100} \left(\beta_0+\beta_1x_i-y_i\right) \\
+\sum_{i=1}^{100}\left( x_i (\beta_0+\beta_1x_i)-y_ix_i\right) \\
+\end{bmatrix} + 2\lambda\begin{bmatrix} \beta_0 \\ \beta_1\end{bmatrix} = 2 (X^T(X\beta - \mathbf{y})+\lambda \beta).
 $$
 
-Using <b>autograd</b> we have
+<p>
+We can now extend our program to minimize \( C_{\text{ridge}}(\beta) \) using gradient descent and compare with the analytical solution given by 
+$$
+\beta_{\text{ridge}} = \left(X^T X + \lambda I_{2 \times 2} \right)^{-1} X^T \mathbf{y},
+$$
+
+for \( \lambda = {0,1,10,50,100} \) (\( \lambda = 0 \) corresponds to ordinary least squares). 
+We can then compute \( ||\beta_{\text{ridge}}|| \) for each \( \lambda \).
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 
-<span style="color: #408080; font-style: italic"># To do elementwise differentiation:</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> elementwise_grad <span style="color: #008000; font-weight: bold">as</span> egrad 
+<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
+<span style="color: #BA2121; font-style: italic">The following setup is just a suggestion, feel free to write it the way you like.</span>
+<span style="color: #BA2121; font-style: italic">&quot;&quot;&quot;</span>
 
-<span style="color: #408080; font-style: italic"># To plot:</span>
-<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span> 
+<span style="color: #408080; font-style: italic">#Setup problem described in the exercise</span>
+N  <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#Nr of datapoints</span>
+M  <span style="color: #666666">=</span> <span style="color: #666666">2</span>   <span style="color: #408080; font-style: italic">#Nr of features</span>
+x  <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(N)
+y  <span style="color: #666666">=</span> <span style="color: #666666">5*</span>x<span style="color: #666666">**2</span> <span style="color: #666666">+</span> <span style="color: #666666">0.1*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(N)
 
 
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f</span>(x):
-    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>sin(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>)
+<span style="color: #408080; font-style: italic">#Compute analytic beta for Ridge regression </span>
+X    <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones(N),x]
+XT_X <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,X)
 
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f_grad_analytic</span>(x):
-    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>cos(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>)<span style="color: #666666">*</span>(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi <span style="color: #666666">+</span> <span style="color: #666666">2*</span>x)
+l  <span style="color: #666666">=</span> <span style="color: #666666">0.1</span> <span style="color: #408080; font-style: italic">#Ridge parameter lambda</span>
+Id <span style="color: #666666">=</span> np<span style="color: #666666">.</span>eye(XT_X<span style="color: #666666">.</span>shape[<span style="color: #666666">0</span>])
 
-<span style="color: #408080; font-style: italic"># Do the comparison:</span>
-x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linspace(<span style="color: #666666">0</span>,<span style="color: #666666">1</span>,<span style="color: #666666">1000</span>)
+Z <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(XT_X<span style="color: #666666">+</span>l<span style="color: #666666">*</span>Id)
+beta_ridge <span style="color: #666666">=</span> np<span style="color: #666666">.</span>dot(Z,np<span style="color: #666666">.</span>dot(X<span style="color: #666666">.</span>T,y))
 
-f_grad <span style="color: #666666">=</span> egrad(f)
-
-computed <span style="color: #666666">=</span> f_grad(x)
-analytic <span style="color: #666666">=</span> f_grad_analytic(x)
-
-plt<span style="color: #666666">.</span>title(<span style="color: #BA2121">&#39;Derivative computed from Autograd compared with the analytical derivative&#39;</span>)
-plt<span style="color: #666666">.</span>plot(x,computed,label<span style="color: #666666">=</span><span style="color: #BA2121">&#39;autograd&#39;</span>)
-plt<span style="color: #666666">.</span>plot(x,analytic,label<span style="color: #666666">=</span><span style="color: #BA2121">&#39;analytic&#39;</span>)
-
-plt<span style="color: #666666">.</span>xlabel(<span style="color: #BA2121">&#39;x&#39;</span>)
-plt<span style="color: #666666">.</span>ylabel(<span style="color: #BA2121">&#39;y&#39;</span>)
-plt<span style="color: #666666">.</span>legend()
-
-plt<span style="color: #666666">.</span>show()
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The max absolute difference is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(np<span style="color: #666666">.</span>max(np<span style="color: #666666">.</span>abs(computed <span style="color: #666666">-</span> analytic))))
+<span style="color: #008000; font-weight: bold">print</span>(beta_ridge)
+<span style="color: #008000; font-weight: bold">print</span>(np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>norm(beta_ridge)) <span style="color: #408080; font-style: italic">#||beta||</span>
 </pre></div>
 <p>
 <p>
@@ -299,7 +333,7 @@ plt<span style="color: #666666">.</span>show()
   <li><a href="._Splines-bs042.html">43</a></li>
   <li><a href="._Splines-bs043.html">44</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs035.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs035.html b/doc/pub/Splines/html/._Splines-bs035.html
index c3514739e..54b3a6010 100644
--- a/doc/pub/Splines/html/._Splines-bs035.html
+++ b/doc/pub/Splines/html/._Splines-bs035.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,37 +251,59 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0035"></a>
-<!-- !split  -->
+<!-- !split -->
 
-<h2 id="___sec34" class="anchor">Using autograd </h2>
+<h2 id="___sec34" class="anchor">Automatic differentiation </h2>
+Python has tools for so-called <b>automatic differentiation</b>.
+Consider the following example
+$$
+f(x) = \sin\left(2\pi x + x^2\right)
+$$
 
-<p>
-Here we
-experiment with what kind of functions Autograd is capable
-of finding the gradient of. The following Python functions are just
-meant to illustrate what Autograd can do, but please feel free to
-experiment with other, possibly more complicated, functions as well.
+which has the following derivative
+$$
+f'(x) = \cos\left(2\pi x + x^2\right)\left(2\pi + 2x\right) 
+$$
+
+Using <b>autograd</b> we have
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
 
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f1</span>(x):
-    <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">**3</span> <span style="color: #666666">+</span> <span style="color: #666666">1</span>
+<span style="color: #408080; font-style: italic"># To do elementwise differentiation:</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> elementwise_grad <span style="color: #008000; font-weight: bold">as</span> egrad 
 
-f1_grad <span style="color: #666666">=</span> grad(f1)
+<span style="color: #408080; font-style: italic"># To plot:</span>
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span> 
 
-<span style="color: #408080; font-style: italic"># Remember to send in float as argument to the computed gradient from Autograd!</span>
-a <span style="color: #666666">=</span> <span style="color: #666666">1.0</span>
 
-<span style="color: #408080; font-style: italic"># See the evaluated gradient at a using autograd:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f1 evaluated at a = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> using autograd is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(a,f1_grad(a)))
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f</span>(x):
+    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>sin(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>)
 
-<span style="color: #408080; font-style: italic"># Compare with the analytical derivative, that is f1&#39;(x) = 3*x**2 </span>
-grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">3*</span>a<span style="color: #666666">**2</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f1 evaluated at a = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> by finding the analytic expression is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(a,grad_analytical))
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f_grad_analytic</span>(x):
+    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>cos(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>)<span style="color: #666666">*</span>(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi <span style="color: #666666">+</span> <span style="color: #666666">2*</span>x)
+
+<span style="color: #408080; font-style: italic"># Do the comparison:</span>
+x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linspace(<span style="color: #666666">0</span>,<span style="color: #666666">1</span>,<span style="color: #666666">1000</span>)
+
+f_grad <span style="color: #666666">=</span> egrad(f)
+
+computed <span style="color: #666666">=</span> f_grad(x)
+analytic <span style="color: #666666">=</span> f_grad_analytic(x)
+
+plt<span style="color: #666666">.</span>title(<span style="color: #BA2121">&#39;Derivative computed from Autograd compared with the analytical derivative&#39;</span>)
+plt<span style="color: #666666">.</span>plot(x,computed,label<span style="color: #666666">=</span><span style="color: #BA2121">&#39;autograd&#39;</span>)
+plt<span style="color: #666666">.</span>plot(x,analytic,label<span style="color: #666666">=</span><span style="color: #BA2121">&#39;analytic&#39;</span>)
+
+plt<span style="color: #666666">.</span>xlabel(<span style="color: #BA2121">&#39;x&#39;</span>)
+plt<span style="color: #666666">.</span>ylabel(<span style="color: #BA2121">&#39;y&#39;</span>)
+plt<span style="color: #666666">.</span>legend()
+
+plt<span style="color: #666666">.</span>show()
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The max absolute difference is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(np<span style="color: #666666">.</span>max(np<span style="color: #666666">.</span>abs(computed <span style="color: #666666">-</span> analytic))))
 </pre></div>
 <p>
 <p>
@@ -277,7 +331,7 @@ grad_analytical <span style="color: #666666">=</span> <span style="color: #66666
   <li><a href="._Splines-bs043.html">44</a></li>
   <li><a href="._Splines-bs044.html">45</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs036.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs036.html b/doc/pub/Splines/html/._Splines-bs036.html
index fc56fb8f5..7bc4f9ea6 100644
--- a/doc/pub/Splines/html/._Splines-bs036.html
+++ b/doc/pub/Splines/html/._Splines-bs036.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,55 +251,38 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0036"></a>
-<!-- !split -->
+<!-- !split  -->
 
-<h2 id="___sec35" class="anchor">Autograd with more complicated functions </h2>
+<h2 id="___sec35" class="anchor">Using autograd </h2>
 
 <p>
-To differentiate with respect to two (or more) arguments of a Python
-function, Autograd need to know at which variable the function if
-being differentiated with respect to.
+Here we
+experiment with what kind of functions Autograd is capable
+of finding the gradient of. The following Python functions are just
+meant to illustrate what Autograd can do, but please feel free to
+experiment with other, possibly more complicated, functions as well.
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f2</span>(x1,x2):
-    <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">3*</span>x1<span style="color: #666666">**3</span> <span style="color: #666666">+</span> x2<span style="color: #666666">*</span>(x1 <span style="color: #666666">-</span> <span style="color: #666666">5</span>) <span style="color: #666666">+</span> <span style="color: #666666">1</span>
 
-<span style="color: #408080; font-style: italic"># By sending the argument 0, Autograd will compute the derivative w.r.t the first variable, in this case x1</span>
-f2_grad_x1 <span style="color: #666666">=</span> grad(f2,<span style="color: #666666">0</span>)
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f1</span>(x):
+    <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">**3</span> <span style="color: #666666">+</span> <span style="color: #666666">1</span>
 
-<span style="color: #408080; font-style: italic"># ... and differentiate w.r.t x2 by sending 1 as an additional arugment to grad</span>
-f2_grad_x2 <span style="color: #666666">=</span> grad(f2,<span style="color: #666666">1</span>)
+f1_grad <span style="color: #666666">=</span> grad(f1)
 
-x1 <span style="color: #666666">=</span> <span style="color: #666666">1.0</span>
-x2 <span style="color: #666666">=</span> <span style="color: #666666">3.0</span> 
+<span style="color: #408080; font-style: italic"># Remember to send in float as argument to the computed gradient from Autograd!</span>
+a <span style="color: #666666">=</span> <span style="color: #666666">1.0</span>
 
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;Evaluating at x1 = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">, x2 = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x1,x2))
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;-&quot;</span><span style="color: #666666">*30</span>)
+<span style="color: #408080; font-style: italic"># See the evaluated gradient at a using autograd:</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f1 evaluated at a = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> using autograd is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(a,f1_grad(a)))
 
-<span style="color: #408080; font-style: italic"># Compare with the analytical derivatives:</span>
-
-<span style="color: #408080; font-style: italic"># Derivative of f2 w.r.t x1 is: 9*x1**2 + x2:</span>
-f2_grad_x1_analytical <span style="color: #666666">=</span> <span style="color: #666666">9*</span>x1<span style="color: #666666">**2</span> <span style="color: #666666">+</span> x2
-
-<span style="color: #408080; font-style: italic"># Derivative of f2 w.r.t x2 is: x1 - 5:</span>
-f2_grad_x2_analytical <span style="color: #666666">=</span> x1 <span style="color: #666666">-</span> <span style="color: #666666">5</span>
-
-<span style="color: #408080; font-style: italic"># See the evaluated derivations:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f2 w.r.t x1: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x1(x1,x2) ))
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f2 w.r.t x1: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x1(x1,x2) ))
-
-<span style="color: #008000; font-weight: bold">print</span>()
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f2 w.r.t x2: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x2(x1,x2) ))
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f2 w.r.t x2: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x2(x1,x2) ))
+<span style="color: #408080; font-style: italic"># Compare with the analytical derivative, that is f1&#39;(x) = 3*x**2 </span>
+grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">3*</span>a<span style="color: #666666">**2</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f1 evaluated at a = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> by finding the analytic expression is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(a,grad_analytical))
 </pre></div>
-<p>
-Note that the grad function will not produce the true gradient of the function. The true gradient of a function with two or more variables will produce a vector, where each element is the function differentiated w.r.t a variable.
-
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -294,7 +309,7 @@ Note that the grad function will not produce the true gradient of the function.
   <li><a href="._Splines-bs044.html">45</a></li>
   <li><a href="._Splines-bs045.html">46</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs037.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs037.html b/doc/pub/Splines/html/._Splines-bs037.html
index 0a7651519..f52b5b3ae 100644
--- a/doc/pub/Splines/html/._Splines-bs037.html
+++ b/doc/pub/Splines/html/._Splines-bs037.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,36 +253,52 @@ MathJax.Hub.Config({
 <a name="part0037"></a>
 <!-- !split -->
 
-<h2 id="___sec36" class="anchor">More complicated functions using the elements of their arguments directly </h2>
+<h2 id="___sec36" class="anchor">Autograd with more complicated functions </h2>
+
+<p>
+To differentiate with respect to two (or more) arguments of a Python
+function, Autograd need to know at which variable the function if
+being differentiated with respect to.
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f3</span>(x): <span style="color: #408080; font-style: italic"># Assumes x is an array of length 5 or higher</span>
-    <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">2*</span>x[<span style="color: #666666">0</span>] <span style="color: #666666">+</span> <span style="color: #666666">3*</span>x[<span style="color: #666666">1</span>] <span style="color: #666666">+</span> <span style="color: #666666">5*</span>x[<span style="color: #666666">2</span>] <span style="color: #666666">+</span> <span style="color: #666666">7*</span>x[<span style="color: #666666">3</span>] <span style="color: #666666">+</span> <span style="color: #666666">11*</span>x[<span style="color: #666666">4</span>]<span style="color: #666666">**2</span>
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f2</span>(x1,x2):
+    <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">3*</span>x1<span style="color: #666666">**3</span> <span style="color: #666666">+</span> x2<span style="color: #666666">*</span>(x1 <span style="color: #666666">-</span> <span style="color: #666666">5</span>) <span style="color: #666666">+</span> <span style="color: #666666">1</span>
 
-f3_grad <span style="color: #666666">=</span> grad(f3)
+<span style="color: #408080; font-style: italic"># By sending the argument 0, Autograd will compute the derivative w.r.t the first variable, in this case x1</span>
+f2_grad_x1 <span style="color: #666666">=</span> grad(f2,<span style="color: #666666">0</span>)
 
-x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linspace(<span style="color: #666666">0</span>,<span style="color: #666666">4</span>,<span style="color: #666666">5</span>)
+<span style="color: #408080; font-style: italic"># ... and differentiate w.r.t x2 by sending 1 as an additional arugment to grad</span>
+f2_grad_x2 <span style="color: #666666">=</span> grad(f2,<span style="color: #666666">1</span>)
 
-<span style="color: #408080; font-style: italic"># Print the computed gradient:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed gradient of f3 is: &quot;</span>, f3_grad(x))
+x1 <span style="color: #666666">=</span> <span style="color: #666666">1.0</span>
+x2 <span style="color: #666666">=</span> <span style="color: #666666">3.0</span> 
 
-<span style="color: #408080; font-style: italic"># The analytical gradient is: (2, 3, 5, 7, 22*x[4])</span>
-f3_grad_analytical <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">2</span>, <span style="color: #666666">3</span>, <span style="color: #666666">5</span>, <span style="color: #666666">7</span>, <span style="color: #666666">22*</span>x[<span style="color: #666666">4</span>]])
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;Evaluating at x1 = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">, x2 = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x1,x2))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;-&quot;</span><span style="color: #666666">*30</span>)
 
-<span style="color: #408080; font-style: italic"># Print the analytical gradient:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical gradient of f3 is: &quot;</span>, f3_grad_analytical)
+<span style="color: #408080; font-style: italic"># Compare with the analytical derivatives:</span>
+
+<span style="color: #408080; font-style: italic"># Derivative of f2 w.r.t x1 is: 9*x1**2 + x2:</span>
+f2_grad_x1_analytical <span style="color: #666666">=</span> <span style="color: #666666">9*</span>x1<span style="color: #666666">**2</span> <span style="color: #666666">+</span> x2
+
+<span style="color: #408080; font-style: italic"># Derivative of f2 w.r.t x2 is: x1 - 5:</span>
+f2_grad_x2_analytical <span style="color: #666666">=</span> x1 <span style="color: #666666">-</span> <span style="color: #666666">5</span>
+
+<span style="color: #408080; font-style: italic"># See the evaluated derivations:</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f2 w.r.t x1: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x1(x1,x2) ))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f2 w.r.t x1: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x1(x1,x2) ))
+
+<span style="color: #008000; font-weight: bold">print</span>()
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f2 w.r.t x2: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x2(x1,x2) ))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f2 w.r.t x2: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>( f2_grad_x2(x1,x2) ))
 </pre></div>
 <p>
-Note that in this case, when sending an array as input argument, the
-output from Autograd is another array. This is the true gradient of
-the function, as opposed to the function in the previous example. By
-using arrays to represent the variables, the output from Autograd
-might be easier to work with, as the output is closer to what one
-could expect form a gradient-evaluting function.
+Note that the grad function will not produce the true gradient of the function. The true gradient of a function with two or more variables will produce a vector, where each element is the function differentiated w.r.t a variable.
 
 <p>
 <p>
@@ -278,7 +326,7 @@ could expect form a gradient-evaluting function.
   <li><a href="._Splines-bs045.html">46</a></li>
   <li><a href="._Splines-bs046.html">47</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs038.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs038.html b/doc/pub/Splines/html/._Splines-bs038.html
index 3719ac6f2..f52485bfa 100644
--- a/doc/pub/Splines/html/._Splines-bs038.html
+++ b/doc/pub/Splines/html/._Splines-bs038.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,31 +251,39 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0038"></a>
-<!-- !split  -->
+<!-- !split -->
 
-<h2 id="___sec37" class="anchor">Functions using mathematical functions from Numpy </h2>
+<h2 id="___sec37" class="anchor">More complicated functions using the elements of their arguments directly </h2>
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f4</span>(x):
-    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>sqrt(<span style="color: #666666">1+</span>x<span style="color: #666666">**2</span>) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>exp(x) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>sin(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x)
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f3</span>(x): <span style="color: #408080; font-style: italic"># Assumes x is an array of length 5 or higher</span>
+    <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">2*</span>x[<span style="color: #666666">0</span>] <span style="color: #666666">+</span> <span style="color: #666666">3*</span>x[<span style="color: #666666">1</span>] <span style="color: #666666">+</span> <span style="color: #666666">5*</span>x[<span style="color: #666666">2</span>] <span style="color: #666666">+</span> <span style="color: #666666">7*</span>x[<span style="color: #666666">3</span>] <span style="color: #666666">+</span> <span style="color: #666666">11*</span>x[<span style="color: #666666">4</span>]<span style="color: #666666">**2</span>
 
-f4_grad <span style="color: #666666">=</span> grad(f4)
+f3_grad <span style="color: #666666">=</span> grad(f3)
 
-x <span style="color: #666666">=</span> <span style="color: #666666">2.7</span>
+x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linspace(<span style="color: #666666">0</span>,<span style="color: #666666">4</span>,<span style="color: #666666">5</span>)
 
-<span style="color: #408080; font-style: italic"># Print the computed derivative:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f4 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f4_grad(x)))
+<span style="color: #408080; font-style: italic"># Print the computed gradient:</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed gradient of f3 is: &quot;</span>, f3_grad(x))
 
-<span style="color: #408080; font-style: italic"># The analytical derivative is: x/sqrt(1 + x**2) + exp(x) + cos(2*pi*x)*2*pi</span>
-f4_grad_analytical <span style="color: #666666">=</span> x<span style="color: #666666">/</span>np<span style="color: #666666">.</span>sqrt(<span style="color: #666666">1</span> <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>exp(x) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>cos(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x)<span style="color: #666666">*2*</span>np<span style="color: #666666">.</span>pi
+<span style="color: #408080; font-style: italic"># The analytical gradient is: (2, 3, 5, 7, 22*x[4])</span>
+f3_grad_analytical <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">2</span>, <span style="color: #666666">3</span>, <span style="color: #666666">5</span>, <span style="color: #666666">7</span>, <span style="color: #666666">22*</span>x[<span style="color: #666666">4</span>]])
 
 <span style="color: #408080; font-style: italic"># Print the analytical gradient:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical gradient of f4 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f4_grad_analytical))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical gradient of f3 is: &quot;</span>, f3_grad_analytical)
 </pre></div>
+<p>
+Note that in this case, when sending an array as input argument, the
+output from Autograd is another array. This is the true gradient of
+the function, as opposed to the function in the previous example. By
+using arrays to represent the variables, the output from Autograd
+might be easier to work with, as the output is closer to what one
+could expect form a gradient-evaluting function.
+
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -270,7 +310,7 @@ f4_grad_analytical <span style="color: #666666">=</span> x<span style="color: #6
   <li><a href="._Splines-bs046.html">47</a></li>
   <li><a href="._Splines-bs047.html">48</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs039.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs039.html b/doc/pub/Splines/html/._Splines-bs039.html
index 54672eb7c..321d77c2f 100644
--- a/doc/pub/Splines/html/._Splines-bs039.html
+++ b/doc/pub/Splines/html/._Splines-bs039.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -219,27 +251,30 @@ MathJax.Hub.Config({
 <p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
 
 <a name="part0039"></a>
-<!-- !split -->
+<!-- !split  -->
 
-<h2 id="___sec38" class="anchor">More autograd </h2>
+<h2 id="___sec38" class="anchor">Functions using mathematical functions from Numpy </h2>
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f5</span>(x):
-    <span style="color: #008000; font-weight: bold">if</span> x <span style="color: #666666">&gt;=</span> <span style="color: #666666">0</span>:
-        <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">**2</span>
-    <span style="color: #008000; font-weight: bold">else</span>:
-        <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">-3*</span>x <span style="color: #666666">+</span> <span style="color: #666666">1</span>
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f4</span>(x):
+    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>sqrt(<span style="color: #666666">1+</span>x<span style="color: #666666">**2</span>) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>exp(x) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>sin(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x)
 
-f5_grad <span style="color: #666666">=</span> grad(f5)
+f4_grad <span style="color: #666666">=</span> grad(f4)
 
 x <span style="color: #666666">=</span> <span style="color: #666666">2.7</span>
 
 <span style="color: #408080; font-style: italic"># Print the computed derivative:</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f5 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f5_grad(x)))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f4 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f4_grad(x)))
+
+<span style="color: #408080; font-style: italic"># The analytical derivative is: x/sqrt(1 + x**2) + exp(x) + cos(2*pi*x)*2*pi</span>
+f4_grad_analytical <span style="color: #666666">=</span> x<span style="color: #666666">/</span>np<span style="color: #666666">.</span>sqrt(<span style="color: #666666">1</span> <span style="color: #666666">+</span> x<span style="color: #666666">**2</span>) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>exp(x) <span style="color: #666666">+</span> np<span style="color: #666666">.</span>cos(<span style="color: #666666">2*</span>np<span style="color: #666666">.</span>pi<span style="color: #666666">*</span>x)<span style="color: #666666">*2*</span>np<span style="color: #666666">.</span>pi
+
+<span style="color: #408080; font-style: italic"># Print the analytical gradient:</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical gradient of f4 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f4_grad_analytical))
 </pre></div>
 <p>
 <p>
@@ -267,7 +302,7 @@ x <span style="color: #666666">=</span> <span style="color: #666666">2.7</span>
   <li><a href="._Splines-bs047.html">48</a></li>
   <li><a href="._Splines-bs048.html">49</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs040.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs040.html b/doc/pub/Splines/html/._Splines-bs040.html
index bc1e9b2b5..bcd088d66 100644
--- a/doc/pub/Splines/html/._Splines-bs040.html
+++ b/doc/pub/Splines/html/._Splines-bs040.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,48 +253,25 @@ MathJax.Hub.Config({
 <a name="part0040"></a>
 <!-- !split -->
 
-<h2 id="___sec39" class="anchor">And  with loops </h2>
+<h2 id="___sec39" class="anchor">More autograd </h2>
 
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f6_for</span>(x):
-    val <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">10</span>):
-        val <span style="color: #666666">=</span> val <span style="color: #666666">+</span> x<span style="color: #666666">**</span>i
-    <span style="color: #008000; font-weight: bold">return</span> val
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f5</span>(x):
+    <span style="color: #008000; font-weight: bold">if</span> x <span style="color: #666666">&gt;=</span> <span style="color: #666666">0</span>:
+        <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">**2</span>
+    <span style="color: #008000; font-weight: bold">else</span>:
+        <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">-3*</span>x <span style="color: #666666">+</span> <span style="color: #666666">1</span>
 
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f6_while</span>(x):
-    val <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-    i <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-    <span style="color: #008000; font-weight: bold">while</span> i <span style="color: #666666">&lt;</span> <span style="color: #666666">10</span>:
-        val <span style="color: #666666">=</span> val <span style="color: #666666">+</span> x<span style="color: #666666">**</span>i
-        i <span style="color: #666666">=</span> i <span style="color: #666666">+</span> <span style="color: #666666">1</span>
-    <span style="color: #008000; font-weight: bold">return</span> val
+f5_grad <span style="color: #666666">=</span> grad(f5)
 
-f6_for_grad <span style="color: #666666">=</span> grad(f6_for)
-f6_while_grad <span style="color: #666666">=</span> grad(f6_while)
+x <span style="color: #666666">=</span> <span style="color: #666666">2.7</span>
 
-x <span style="color: #666666">=</span> <span style="color: #666666">0.5</span>
-
-<span style="color: #408080; font-style: italic"># Print the computed derivaties of f6_for and f6_while</span>
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f6_for at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_for_grad(x)))
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f6_while at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_while_grad(x)))
-</pre></div>
-<p>
-
-<!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #408080; font-style: italic"># Both of the functions are implementation of the sum: sum(x**i) for i = 0, ..., 9</span>
-<span style="color: #408080; font-style: italic"># The analytical derivative is: sum(i*x**(i-1)) </span>
-f6_grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-<span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">10</span>):
-    f6_grad_analytical <span style="color: #666666">+=</span> i<span style="color: #666666">*</span>x<span style="color: #666666">**</span>(i<span style="color: #666666">-1</span>)
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f6 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_grad_analytical))
+<span style="color: #408080; font-style: italic"># Print the computed derivative:</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f5 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f5_grad(x)))
 </pre></div>
 <p>
 <p>
@@ -290,7 +299,7 @@ f6_grad_analytical <span style="color: #666666">=</span> <span style="color: #66
   <li><a href="._Splines-bs048.html">49</a></li>
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs041.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs041.html b/doc/pub/Splines/html/._Splines-bs041.html
index fd0cac4ea..5d8280745 100644
--- a/doc/pub/Splines/html/._Splines-bs041.html
+++ b/doc/pub/Splines/html/._Splines-bs041.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,41 +253,49 @@ MathJax.Hub.Config({
 <a name="part0041"></a>
 <!-- !split -->
 
-<h2 id="___sec40" class="anchor">Using recursion </h2>
+<h2 id="___sec40" class="anchor">And  with loops </h2>
+
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f6_for</span>(x):
+    val <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">10</span>):
+        val <span style="color: #666666">=</span> val <span style="color: #666666">+</span> x<span style="color: #666666">**</span>i
+    <span style="color: #008000; font-weight: bold">return</span> val
 
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f7</span>(n): <span style="color: #408080; font-style: italic"># Assume that n is an integer</span>
-    <span style="color: #008000; font-weight: bold">if</span> n <span style="color: #666666">==</span> <span style="color: #666666">1</span> <span style="color: #AA22FF; font-weight: bold">or</span> n <span style="color: #666666">==</span> <span style="color: #666666">0</span>:
-        <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">1</span>
-    <span style="color: #008000; font-weight: bold">else</span>:
-        <span style="color: #008000; font-weight: bold">return</span> n<span style="color: #666666">*</span>f7(n<span style="color: #666666">-1</span>)
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f6_while</span>(x):
+    val <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+    i <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+    <span style="color: #008000; font-weight: bold">while</span> i <span style="color: #666666">&lt;</span> <span style="color: #666666">10</span>:
+        val <span style="color: #666666">=</span> val <span style="color: #666666">+</span> x<span style="color: #666666">**</span>i
+        i <span style="color: #666666">=</span> i <span style="color: #666666">+</span> <span style="color: #666666">1</span>
+    <span style="color: #008000; font-weight: bold">return</span> val
 
-f7_grad <span style="color: #666666">=</span> grad(f7)
+f6_for_grad <span style="color: #666666">=</span> grad(f6_for)
+f6_while_grad <span style="color: #666666">=</span> grad(f6_while)
 
-n <span style="color: #666666">=</span> <span style="color: #666666">2.0</span>
+x <span style="color: #666666">=</span> <span style="color: #666666">0.5</span>
 
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f7 at n = </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(n,f7_grad(n)))
-
-<span style="color: #408080; font-style: italic"># The function f7 is an implementation of the factorial of n.</span>
-<span style="color: #408080; font-style: italic"># By using the product rule, one can find that the derivative is:</span>
-
-f7_grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-<span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #008000">int</span>(n)<span style="color: #666666">-1</span>):
-    tmp <span style="color: #666666">=</span> <span style="color: #666666">1</span>
-    <span style="color: #008000; font-weight: bold">for</span> k <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #008000">int</span>(n)<span style="color: #666666">-1</span>):
-        <span style="color: #008000; font-weight: bold">if</span> k <span style="color: #666666">!=</span> i:
-            tmp <span style="color: #666666">*=</span> (n <span style="color: #666666">-</span> k)
-    f7_grad_analytical <span style="color: #666666">+=</span> tmp
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f7 at n = </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(n,f7_grad_analytical))
+<span style="color: #408080; font-style: italic"># Print the computed derivaties of f6_for and f6_while</span>
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f6_for at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_for_grad(x)))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f6_while at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_while_grad(x)))
 </pre></div>
 <p>
-Note that if n is equal to zero or one, Autograd will give an error message. This message appears when the output is independent on input.
 
+<!-- code=python (!bc pycod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
+<span style="color: #408080; font-style: italic"># Both of the functions are implementation of the sum: sum(x**i) for i = 0, ..., 9</span>
+<span style="color: #408080; font-style: italic"># The analytical derivative is: sum(i*x**(i-1)) </span>
+f6_grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+<span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">10</span>):
+    f6_grad_analytical <span style="color: #666666">+=</span> i<span style="color: #666666">*</span>x<span style="color: #666666">**</span>(i<span style="color: #666666">-1</span>)
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f6 at x = </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(x,f6_grad_analytical))
+</pre></div>
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -282,7 +322,7 @@ Note that if n is equal to zero or one, Autograd will give an error message. Thi
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs042.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs042.html b/doc/pub/Splines/html/._Splines-bs042.html
index 961369bb5..6cb15cdf2 100644
--- a/doc/pub/Splines/html/._Splines-bs042.html
+++ b/doc/pub/Splines/html/._Splines-bs042.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,28 +253,40 @@ MathJax.Hub.Config({
 <a name="part0042"></a>
 <!-- !split -->
 
-<h2 id="___sec41" class="anchor">Unsupported functions </h2>
-Autograd supports many features. However, there are some functions that is not supported (yet) by Autograd.
-
-<p>
-Assigning a value to the variable being differentiated with respect to
+<h2 id="___sec41" class="anchor">Using recursion </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f8</span>(x): <span style="color: #408080; font-style: italic"># Assume x is an array</span>
-    x[<span style="color: #666666">2</span>] <span style="color: #666666">=</span> <span style="color: #666666">3</span>
-    <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">*2</span>
 
-f8_grad <span style="color: #666666">=</span> grad(f8)
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f7</span>(n): <span style="color: #408080; font-style: italic"># Assume that n is an integer</span>
+    <span style="color: #008000; font-weight: bold">if</span> n <span style="color: #666666">==</span> <span style="color: #666666">1</span> <span style="color: #AA22FF; font-weight: bold">or</span> n <span style="color: #666666">==</span> <span style="color: #666666">0</span>:
+        <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">1</span>
+    <span style="color: #008000; font-weight: bold">else</span>:
+        <span style="color: #008000; font-weight: bold">return</span> n<span style="color: #666666">*</span>f7(n<span style="color: #666666">-1</span>)
 
-x <span style="color: #666666">=</span> <span style="color: #666666">8.4</span>
+f7_grad <span style="color: #666666">=</span> grad(f7)
 
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f8 is:&quot;</span>,f8_grad(x))
+n <span style="color: #666666">=</span> <span style="color: #666666">2.0</span>
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The computed derivative of f7 at n = </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(n,f7_grad(n)))
+
+<span style="color: #408080; font-style: italic"># The function f7 is an implementation of the factorial of n.</span>
+<span style="color: #408080; font-style: italic"># By using the product rule, one can find that the derivative is:</span>
+
+f7_grad_analytical <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+<span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #008000">int</span>(n)<span style="color: #666666">-1</span>):
+    tmp <span style="color: #666666">=</span> <span style="color: #666666">1</span>
+    <span style="color: #008000; font-weight: bold">for</span> k <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #008000">int</span>(n)<span style="color: #666666">-1</span>):
+        <span style="color: #008000; font-weight: bold">if</span> k <span style="color: #666666">!=</span> i:
+            tmp <span style="color: #666666">*=</span> (n <span style="color: #666666">-</span> k)
+    f7_grad_analytical <span style="color: #666666">+=</span> tmp
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The analytical derivative of f7 at n = </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> is: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span><span style="color: #666666">%</span>(n,f7_grad_analytical))
 </pre></div>
 <p>
-Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The item assignment is done when the program tries to assign x[2] to the value 3. However, Autograd has implemented the computation of the derivative such that this assignment is not possible.
+Note that if n is equal to zero or one, Autograd will give an error message. This message appears when the output is independent on input.
 
 <p>
 <p>
@@ -269,6 +313,8 @@ Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs043.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs043.html b/doc/pub/Splines/html/._Splines-bs043.html
index e673f8832..3a8efd0d2 100644
--- a/doc/pub/Splines/html/._Splines-bs043.html
+++ b/doc/pub/Splines/html/._Splines-bs043.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,45 +253,29 @@ MathJax.Hub.Config({
 <a name="part0043"></a>
 <!-- !split -->
 
-<h2 id="___sec42" class="anchor">The syntax a.dot(b) when finding the dot product </h2>
+<h2 id="___sec42" class="anchor">Unsupported functions </h2>
+Autograd supports many features. However, there are some functions that is not supported (yet) by Autograd.
+
+<p>
+Assigning a value to the variable being differentiated with respect to
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
 <div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
 <span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f9</span>(a): <span style="color: #408080; font-style: italic"># Assume a is an array with 2 elements</span>
-    b <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">2.0</span>])
-    <span style="color: #008000; font-weight: bold">return</span> a<span style="color: #666666">.</span>dot(b)
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f8</span>(x): <span style="color: #408080; font-style: italic"># Assume x is an array</span>
+    x[<span style="color: #666666">2</span>] <span style="color: #666666">=</span> <span style="color: #666666">3</span>
+    <span style="color: #008000; font-weight: bold">return</span> x<span style="color: #666666">*2</span>
 
-f9_grad <span style="color: #666666">=</span> grad(f9)
+f8_grad <span style="color: #666666">=</span> grad(f8)
 
-x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">0.0</span>])
+x <span style="color: #666666">=</span> <span style="color: #666666">8.4</span>
 
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f9 is:&quot;</span>,f9_grad(x))
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f8 is:&quot;</span>,f8_grad(x))
 </pre></div>
 <p>
-Here we are told that the 'dot' function does not belong to Autograd's
-version of a Numpy array.  To overcome this, an alternative syntax
-which also computed the dot product can be used:
+Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The item assignment is done when the program tries to assign x[2] to the value 3. However, Autograd has implemented the computation of the derivative such that this assignment is not possible.
 
-<p>
-
-<!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
-<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f9_alternative</span>(x): <span style="color: #408080; font-style: italic"># Assume a is an array with 2 elements</span>
-    b <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">2.0</span>])
-    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>dot(x,b) <span style="color: #408080; font-style: italic"># The same as x_1*b_1 + x_2*b_2</span>
-
-f9_alternative_grad <span style="color: #666666">=</span> grad(f9_alternative)
-
-x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">3.0</span>,<span style="color: #666666">0.0</span>])
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f9 is:&quot;</span>,f9_alternative_grad(x))
-
-<span style="color: #408080; font-style: italic"># The analytical gradient of the dot product of vectors x and b with two elements (x_1,x_2) and (b_1, b_2) respectively</span>
-<span style="color: #408080; font-style: italic"># w.r.t x is (b_1, b_2).</span>
-</pre></div>
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -284,6 +300,9 @@ x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>a
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs044.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs044.html b/doc/pub/Splines/html/._Splines-bs044.html
index c9cb5e6d3..bcf453fb9 100644
--- a/doc/pub/Splines/html/._Splines-bs044.html
+++ b/doc/pub/Splines/html/._Splines-bs044.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,15 +253,44 @@ MathJax.Hub.Config({
 <a name="part0044"></a>
 <!-- !split -->
 
-<h2 id="___sec43" class="anchor">Recommended to avoid </h2>
-The documentation recommends to avoid inplace operations such as
+<h2 id="___sec43" class="anchor">The syntax a.dot(b) when finding the dot product </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span>a <span style="color: #666666">+=</span> b
-a <span style="color: #666666">-=</span> b
-a<span style="color: #666666">*=</span> b
-a <span style="color: #666666">/=</span>b
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f9</span>(a): <span style="color: #408080; font-style: italic"># Assume a is an array with 2 elements</span>
+    b <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">2.0</span>])
+    <span style="color: #008000; font-weight: bold">return</span> a<span style="color: #666666">.</span>dot(b)
+
+f9_grad <span style="color: #666666">=</span> grad(f9)
+
+x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">0.0</span>])
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The derivative of f9 is:&quot;</span>,f9_grad(x))
+</pre></div>
+<p>
+Here we are told that the 'dot' function does not belong to Autograd's
+version of a Numpy array.  To overcome this, an alternative syntax
+which also computed the dot product can be used:
+
+<p>
+
+<!-- code=python (!bc pycod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">autograd.numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">autograd</span> <span style="color: #008000; font-weight: bold">import</span> grad
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">f9_alternative</span>(x): <span style="color: #408080; font-style: italic"># Assume a is an array with 2 elements</span>
+    b <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">1.0</span>,<span style="color: #666666">2.0</span>])
+    <span style="color: #008000; font-weight: bold">return</span> np<span style="color: #666666">.</span>dot(x,b) <span style="color: #408080; font-style: italic"># The same as x_1*b_1 + x_2*b_2</span>
+
+f9_alternative_grad <span style="color: #666666">=</span> grad(f9_alternative)
+
+x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([<span style="color: #666666">3.0</span>,<span style="color: #666666">0.0</span>])
+
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;The gradient of f9 is:&quot;</span>,f9_alternative_grad(x))
+
+<span style="color: #408080; font-style: italic"># The analytical gradient of the dot product of vectors x and b with two elements (x_1,x_2) and (b_1, b_2) respectively</span>
+<span style="color: #408080; font-style: italic"># w.r.t x is (b_1, b_2).</span>
 </pre></div>
 <p>
 <p>
@@ -254,6 +315,10 @@ a <span style="color: #666666">/=</span>b
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs045.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs045.html b/doc/pub/Splines/html/._Splines-bs045.html
index e7e69ea8a..ed13b7ea9 100644
--- a/doc/pub/Splines/html/._Splines-bs045.html
+++ b/doc/pub/Splines/html/._Splines-bs045.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,21 +253,16 @@ MathJax.Hub.Config({
 <a name="part0045"></a>
 <!-- !split -->
 
-<h2 id="___sec44" class="anchor">Stochastic Gradient Descent </h2>
-
+<h2 id="___sec44" class="anchor">Recommended to avoid </h2>
+The documentation recommends to avoid inplace operations such as
 <p>
-Stochastic gradient descent (SGD) and variants thereof address some of
-the shortcomings of the Gradient descent method discussed above.
-
-<p>
-The underlying idea of SGD comes from the observation that the cost
-function, which we want to minimize, can almost always be written as a
-sum over \( n \) data points \( \{\mathbf{x}_i\}_{i=1}^n \),
-$$
-C(\mathbf{\beta}) = \sum_{i=1}^n c_i(\mathbf{x}_i,
-\mathbf{\beta}). 
-$$
 
+<!-- code=python (!bc pycod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span>a <span style="color: #666666">+=</span> b
+a <span style="color: #666666">-=</span> b
+a<span style="color: #666666">*=</span> b
+a <span style="color: #666666">/=</span>b
+</pre></div>
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -258,6 +285,11 @@ $$
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs046.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs046.html b/doc/pub/Splines/html/._Splines-bs046.html
index b742225d3..ff588e0ad 100644
--- a/doc/pub/Splines/html/._Splines-bs046.html
+++ b/doc/pub/Splines/html/._Splines-bs046.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,22 +253,20 @@ MathJax.Hub.Config({
 <a name="part0046"></a>
 <!-- !split -->
 
-<h2 id="___sec45" class="anchor">Computation of gradients </h2>
+<h2 id="___sec45" class="anchor">Stochastic Gradient Descent </h2>
 
 <p>
-This in turn means that the gradient can be
-computed as a sum over \( i \)-gradients 
-$$
-\nabla_\beta C(\mathbf{\beta}) = \sum_i^n \nabla_\beta c_i(\mathbf{x}_i,
-\mathbf{\beta}).
-$$
+Stochastic gradient descent (SGD) and variants thereof address some of
+the shortcomings of the Gradient descent method discussed above.
 
 <p>
-Stochasticity/randomness is introduced by only taking the
-gradient on a subset of the data called minibatches.  If there are \( n \)
-data points and the size of each minibatch is \( M \), there will be \( n/M \)
-minibatches. We denote these minibatches by \( B_k \) where
-\( k=1,\cdots,n/M \).
+The underlying idea of SGD comes from the observation that the cost
+function, which we want to minimize, can almost always be written as a
+sum over \( n \) data points \( \{\mathbf{x}_i\}_{i=1}^n \),
+$$
+C(\mathbf{\beta}) = \sum_{i=1}^n c_i(\mathbf{x}_i,
+\mathbf{\beta}). 
+$$
 
 <p>
 <p>
@@ -259,6 +289,12 @@ minibatches. We denote these minibatches by \( B_k \) where
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs047.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs047.html b/doc/pub/Splines/html/._Splines-bs047.html
index a650b62e9..2708ba343 100644
--- a/doc/pub/Splines/html/._Splines-bs047.html
+++ b/doc/pub/Splines/html/._Splines-bs047.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,27 +253,23 @@ MathJax.Hub.Config({
 <a name="part0047"></a>
 <!-- !split -->
 
-<h2 id="___sec46" class="anchor">SGD example </h2>
-As an example, suppose we have \( 10 \) data points \( (\mathbf{x}_1,\cdots, \mathbf{x}_{10}) \) 
-and we choose to have \( M=5 \) minibathces,
-then each minibatch contains two data points. In particular we have
-\( B_1 = (\mathbf{x}_1,\mathbf{x}_2), \cdots, B_5 =
-(\mathbf{x}_9,\mathbf{x}_{10}) \). Note that if you choose \( M=1 \) you
-have only a single batch with all data points and on the other extreme,
-you may choose \( M=n \) resulting in a minibatch for each datapoint, i.e
-\( B_k = \mathbf{x}_k \).
+<h2 id="___sec46" class="anchor">Computation of gradients </h2>
 
 <p>
-The idea is now to approximate the gradient by replacing the sum over
-all data points with a sum over the data points in one the minibatches
-picked at random in each gradient descent step 
+This in turn means that the gradient can be
+computed as a sum over \( i \)-gradients 
 $$
-\nabla_{\beta}
-C(\mathbf{\beta}) = \sum_{i=1}^n \nabla_\beta c_i(\mathbf{x}_i,
-\mathbf{\beta}) \rightarrow \sum_{i \in B_k}^n \nabla_\beta
-c_i(\mathbf{x}_i, \mathbf{\beta}).
+\nabla_\beta C(\mathbf{\beta}) = \sum_i^n \nabla_\beta c_i(\mathbf{x}_i,
+\mathbf{\beta}).
 $$
 
+<p>
+Stochasticity/randomness is introduced by only taking the
+gradient on a subset of the data called minibatches.  If there are \( n \)
+data points and the size of each minibatch is \( M \), there will be \( n/M \)
+minibatches. We denote these minibatches by \( B_k \) where
+\( k=1,\cdots,n/M \).
+
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -262,6 +290,13 @@ $$
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs048.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs048.html b/doc/pub/Splines/html/._Splines-bs048.html
index d6ae3e5ac..d602f4e3f 100644
--- a/doc/pub/Splines/html/._Splines-bs048.html
+++ b/doc/pub/Splines/html/._Splines-bs048.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,22 +253,27 @@ MathJax.Hub.Config({
 <a name="part0048"></a>
 <!-- !split -->
 
-<h2 id="___sec47" class="anchor">The gradient step </h2>
+<h2 id="___sec47" class="anchor">SGD example </h2>
+As an example, suppose we have \( 10 \) data points \( (\mathbf{x}_1,\cdots, \mathbf{x}_{10}) \) 
+and we choose to have \( M=5 \) minibathces,
+then each minibatch contains two data points. In particular we have
+\( B_1 = (\mathbf{x}_1,\mathbf{x}_2), \cdots, B_5 =
+(\mathbf{x}_9,\mathbf{x}_{10}) \). Note that if you choose \( M=1 \) you
+have only a single batch with all data points and on the other extreme,
+you may choose \( M=n \) resulting in a minibatch for each datapoint, i.e
+\( B_k = \mathbf{x}_k \).
 
 <p>
-Thus a gradient descent step now looks like 
+The idea is now to approximate the gradient by replacing the sum over
+all data points with a sum over the data points in one the minibatches
+picked at random in each gradient descent step 
 $$
-\beta_{j+1} = \beta_j - \gamma_j \sum_{i \in B_k}^n \nabla_\beta c_i(\mathbf{x}_i,
-\mathbf{\beta})
+\nabla_{\beta}
+C(\mathbf{\beta}) = \sum_{i=1}^n \nabla_\beta c_i(\mathbf{x}_i,
+\mathbf{\beta}) \rightarrow \sum_{i \in B_k}^n \nabla_\beta
+c_i(\mathbf{x}_i, \mathbf{\beta}).
 $$
 
-<p>
-where \( k \) is picked at random with equal
-probability from \( [1,n/M] \). An iteration over the number of
-minibathces (n/M) is commonly referred to as an epoch. Thus it is
-typical to choose a number of epochs and for each epoch iterate over
-the number of minibatches, as exemplified in the code below.
-
 <p>
 <p>
 <!-- navigation buttons at the bottom of the page -->
@@ -256,6 +293,14 @@ the number of minibatches, as exemplified in the code below.
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="._Splines-bs057.html">58</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs049.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs049.html b/doc/pub/Splines/html/._Splines-bs049.html
index aed71216c..8c110af9a 100644
--- a/doc/pub/Splines/html/._Splines-bs049.html
+++ b/doc/pub/Splines/html/._Splines-bs049.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,34 +253,21 @@ MathJax.Hub.Config({
 <a name="part0049"></a>
 <!-- !split -->
 
-<h2 id="___sec48" class="anchor">Simple example code </h2>
+<h2 id="___sec48" class="anchor">The gradient step </h2>
 
 <p>
+Thus a gradient descent step now looks like 
+$$
+\beta_{j+1} = \beta_j - \gamma_j \sum_{i \in B_k}^n \nabla_\beta c_i(\mathbf{x}_i,
+\mathbf{\beta})
+$$
 
-<!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span> 
-
-n <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#100 datapoints </span>
-M <span style="color: #666666">=</span> <span style="color: #666666">5</span>   <span style="color: #408080; font-style: italic">#size of each minibatch</span>
-m <span style="color: #666666">=</span> <span style="color: #008000">int</span>(n<span style="color: #666666">/</span>M) <span style="color: #408080; font-style: italic">#number of minibatches</span>
-n_epochs <span style="color: #666666">=</span> <span style="color: #666666">10</span> <span style="color: #408080; font-style: italic">#number of epochs</span>
-
-j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-<span style="color: #008000; font-weight: bold">for</span> epoch <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">1</span>,n_epochs<span style="color: #666666">+1</span>):
-    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(m):
-        k <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randint(m) <span style="color: #408080; font-style: italic">#Pick the k-th minibatch at random</span>
-        <span style="color: #408080; font-style: italic">#Compute the gradient using the data in minibatch Bk</span>
-        <span style="color: #408080; font-style: italic">#Compute new suggestion for </span>
-        j <span style="color: #666666">+=</span> <span style="color: #666666">1</span>
-</pre></div>
 <p>
-Taking the gradient only on a subset of the data has two important
-benefits. First, it introduces randomness which decreases the chance
-that our opmization scheme gets stuck in a local minima. Second, if
-the size of the minibatches are small relative to the number of
-datapoints (\( M <  n \)), the computation of the gradient is much
-cheaper since we sum over the datapoints in the \( k-th \) minibatch and not
-all \( n \) datapoints.
+where \( k \) is picked at random with equal
+probability from \( [1,n/M] \). An iteration over the number of
+minibathces (n/M) is commonly referred to as an epoch. Thus it is
+typical to choose a number of epochs and for each epoch iterate over
+the number of minibatches, as exemplified in the code below.
 
 <p>
 <p>
@@ -268,6 +287,15 @@ all \( n \) datapoints.
   <li class="active"><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="._Splines-bs057.html">58</a></li>
+  <li><a href="._Splines-bs058.html">59</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs050.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs050.html b/doc/pub/Splines/html/._Splines-bs050.html
index 987a9c6a5..a0ba39efb 100644
--- a/doc/pub/Splines/html/._Splines-bs050.html
+++ b/doc/pub/Splines/html/._Splines-bs050.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,19 +253,34 @@ MathJax.Hub.Config({
 <a name="part0050"></a>
 <!-- !split -->
 
-<h2 id="___sec49" class="anchor">When do we stop? </h2>
+<h2 id="___sec49" class="anchor">Simple example code </h2>
 
 <p>
-A natural question is when do we stop the search for a new minimum?
-One possibility is to compute the full gradient after a given number
-of epochs and check if the norm of the gradient is smaller than some
-threshold and stop if true. However, the condition that the gradient
-is zero is valid also for local minima, so this would only tell us
-that we are close to a local/global minimum. However, we could also
-evaluate the cost function at this point, store the result and
-continue the search. If the test kicks in at a later stage we can
-compare the values of the cost function and keep the \( \beta \) that
-gave the lowest value.
+
+<!-- code=python (!bc pycod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span> 
+
+n <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#100 datapoints </span>
+M <span style="color: #666666">=</span> <span style="color: #666666">5</span>   <span style="color: #408080; font-style: italic">#size of each minibatch</span>
+m <span style="color: #666666">=</span> <span style="color: #008000">int</span>(n<span style="color: #666666">/</span>M) <span style="color: #408080; font-style: italic">#number of minibatches</span>
+n_epochs <span style="color: #666666">=</span> <span style="color: #666666">10</span> <span style="color: #408080; font-style: italic">#number of epochs</span>
+
+j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
+<span style="color: #008000; font-weight: bold">for</span> epoch <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">1</span>,n_epochs<span style="color: #666666">+1</span>):
+    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(m):
+        k <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randint(m) <span style="color: #408080; font-style: italic">#Pick the k-th minibatch at random</span>
+        <span style="color: #408080; font-style: italic">#Compute the gradient using the data in minibatch Bk</span>
+        <span style="color: #408080; font-style: italic">#Compute new suggestion for </span>
+        j <span style="color: #666666">+=</span> <span style="color: #666666">1</span>
+</pre></div>
+<p>
+Taking the gradient only on a subset of the data has two important
+benefits. First, it introduces randomness which decreases the chance
+that our opmization scheme gets stuck in a local minima. Second, if
+the size of the minibatches are small relative to the number of
+datapoints (\( M <  n \)), the computation of the gradient is much
+cheaper since we sum over the datapoints in the \( k-th \) minibatch and not
+all \( n \) datapoints.
 
 <p>
 <p>
@@ -252,6 +299,16 @@ gave the lowest value.
   <li><a href="._Splines-bs049.html">50</a></li>
   <li class="active"><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="._Splines-bs057.html">58</a></li>
+  <li><a href="._Splines-bs058.html">59</a></li>
+  <li><a href="._Splines-bs059.html">60</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs051.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/._Splines-bs051.html b/doc/pub/Splines/html/._Splines-bs051.html
index 4202b23c2..c27ba6568 100644
--- a/doc/pub/Splines/html/._Splines-bs051.html
+++ b/doc/pub/Splines/html/._Splines-bs051.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -221,53 +253,21 @@ MathJax.Hub.Config({
 <a name="part0051"></a>
 <!-- !split -->
 
-<h2 id="___sec50" class="anchor">Slightly different approach </h2>
+<h2 id="___sec50" class="anchor">When do we stop? </h2>
 
 <p>
-Another approach is to let the step length \( \gamma_j \) depend on the
-number of epochs in such a way that it becomes very small after a
-reasonable time such that we do not move at all.
+A natural question is when do we stop the search for a new minimum?
+One possibility is to compute the full gradient after a given number
+of epochs and check if the norm of the gradient is smaller than some
+threshold and stop if true. However, the condition that the gradient
+is zero is valid also for local minima, so this would only tell us
+that we are close to a local/global minimum. However, we could also
+evaluate the cost function at this point, store the result and
+continue the search. If the test kicks in at a later stage we can
+compare the values of the cost function and keep the \( \beta \) that
+gave the lowest value.
 
 <p>
-As an example, let \( e = 0,1,2,3,\cdots \) denote the current epoch and let \( t_0, t_1 > 0 \) be two fixed numbers. Furthermore, let \( t = e \cdot m + i \) where \( m \) is the number of minibatches and \( i=0,\cdots,m-1 \). Then the function $$\gamma_j(t; t_0, t_1) = \frac{t_0}{t+t_1} $$ goes to zero as the number of epochs gets large. I.e. we start with a step length \( \gamma_j (0; t_0, t_1) = t_0/t_1 \) which decays in <em>time</em> \( t \).
-
-<p>
-In this way we can fix the number of epochs, compute \( \beta \) and
-evaluate the cost function at the end. Repeating the computation will
-give a different result since the scheme is random by design. Then we
-pick the final \( \beta \) that gives the lowest value of the cost
-function.
-
-<p>
-
-<!-- code=python (!bc pycod) typeset with pygments style "default" -->
-<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span> 
-
-<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">step_length</span>(t,t0,t1):
-    <span style="color: #008000; font-weight: bold">return</span> t0<span style="color: #666666">/</span>(t<span style="color: #666666">+</span>t1)
-
-n <span style="color: #666666">=</span> <span style="color: #666666">100</span> <span style="color: #408080; font-style: italic">#100 datapoints </span>
-M <span style="color: #666666">=</span> <span style="color: #666666">5</span>   <span style="color: #408080; font-style: italic">#size of each minibatch</span>
-m <span style="color: #666666">=</span> <span style="color: #008000">int</span>(n<span style="color: #666666">/</span>M) <span style="color: #408080; font-style: italic">#number of minibatches</span>
-n_epochs <span style="color: #666666">=</span> <span style="color: #666666">500</span> <span style="color: #408080; font-style: italic">#number of epochs</span>
-t0 <span style="color: #666666">=</span> <span style="color: #666666">1.0</span>
-t1 <span style="color: #666666">=</span> <span style="color: #666666">10</span>
-
-gamma_j <span style="color: #666666">=</span> t0<span style="color: #666666">/</span>t1
-j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
-<span style="color: #008000; font-weight: bold">for</span> epoch <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(<span style="color: #666666">1</span>,n_epochs<span style="color: #666666">+1</span>):
-    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(m):
-        k <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randint(m) <span style="color: #408080; font-style: italic">#Pick the k-th minibatch at random</span>
-        <span style="color: #408080; font-style: italic">#Compute the gradient using the data in minibatch Bk</span>
-        <span style="color: #408080; font-style: italic">#Compute new suggestion for beta</span>
-        t <span style="color: #666666">=</span> epoch<span style="color: #666666">*</span>m<span style="color: #666666">+</span>i
-        gamma_j <span style="color: #666666">=</span> step_length(t,t0,t1)
-        j <span style="color: #666666">+=</span> <span style="color: #666666">1</span>
-
-<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;gamma_j after </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> epochs: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span> <span style="color: #666666">%</span> (n_epochs,gamma_j))
-</pre></div>
-<p>
-
 <p>
 <!-- navigation buttons at the bottom of the page -->
 <ul class="pagination">
@@ -283,6 +283,18 @@ j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
   <li><a href="._Splines-bs049.html">50</a></li>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li class="active"><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="._Splines-bs057.html">58</a></li>
+  <li><a href="._Splines-bs058.html">59</a></li>
+  <li><a href="._Splines-bs059.html">60</a></li>
+  <li><a href="._Splines-bs060.html">61</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
+  <li><a href="._Splines-bs052.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
 
diff --git a/doc/pub/Splines/html/._Splines-bs052.html b/doc/pub/Splines/html/._Splines-bs052.html
index 7c61f2b94..2b2dac843 100644
--- a/doc/pub/Splines/html/._Splines-bs052.html
+++ b/doc/pub/Splines/html/._Splines-bs052.html
@@ -68,18 +68,18 @@ Automatically generated HTML file from DocOnce source
               ('Gradient method', 2, None, '___sec18'),
               ('Steepest descent  method', 2, None, '___sec19'),
               ('Steepest descent  method', 2, None, '___sec20'),
-              ('Gradient descent method', 2, None, '___sec21'),
-              ('Final expressions', 2, None, '___sec22'),
+              ('Final expressions', 2, None, '___sec21'),
               ('Simple codes for  steepest descent and conjugate gradient '
                'using a $2\\times 2$ matrix, in c++, Python code to come',
                2,
                None,
-               '___sec23'),
+               '___sec22'),
               ('The routine for the steepest descent method',
                2,
                None,
-               '___sec24'),
-              ('Steepest descent example', 2, None, '___sec25'),
+               '___sec23'),
+              ('Steepest descent example', 2, None, '___sec24'),
+              ('Conjugate gradient', 2, None, '___sec25'),
               ('Revisiting our first homework', 2, None, '___sec26'),
               ('Gradient descent example', 2, None, '___sec27'),
               ('The derivative of the cost/loss function', 2, None, '___sec28'),
@@ -118,7 +118,25 @@ Automatically generated HTML file from DocOnce source
               ('The gradient step', 2, None, '___sec48'),
               ('Simple example code', 2, None, '___sec49'),
               ('When do we stop?', 2, None, '___sec50'),
-              ('Slightly different approach', 2, None, '___sec51')]}
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -177,11 +195,11 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs019.html#___sec18" style="font-size: 80%;">Gradient method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs020.html#___sec19" style="font-size: 80%;">Steepest descent  method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs021.html#___sec20" style="font-size: 80%;">Steepest descent  method</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs022.html#___sec21" style="font-size: 80%;">Gradient descent method</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Final expressions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">The routine for the steepest descent method</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Steepest descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs022.html#___sec21" style="font-size: 80%;">Final expressions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
@@ -208,6 +226,18 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
      <!-- navigation toc: --> <li><a href="#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -269,7 +299,6 @@ j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
 <span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;gamma_j after </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> epochs: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span> <span style="color: #666666">%</span> (n_epochs,gamma_j))
 </pre></div>
 <p>
-
 <p>
 <!-- navigation buttons at the bottom of the page -->
 <ul class="pagination">
@@ -285,6 +314,18 @@ j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
   <li><a href="._Splines-bs050.html">51</a></li>
   <li><a href="._Splines-bs051.html">52</a></li>
   <li class="active"><a href="._Splines-bs052.html">53</a></li>
+  <li><a href="._Splines-bs053.html">54</a></li>
+  <li><a href="._Splines-bs054.html">55</a></li>
+  <li><a href="._Splines-bs055.html">56</a></li>
+  <li><a href="._Splines-bs056.html">57</a></li>
+  <li><a href="._Splines-bs057.html">58</a></li>
+  <li><a href="._Splines-bs058.html">59</a></li>
+  <li><a href="._Splines-bs059.html">60</a></li>
+  <li><a href="._Splines-bs060.html">61</a></li>
+  <li><a href="._Splines-bs061.html">62</a></li>
+  <li><a href="">...</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
+  <li><a href="._Splines-bs053.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
 
diff --git a/doc/pub/Splines/html/Splines-bs.html b/doc/pub/Splines/html/Splines-bs.html
index 746f6012c..bece1e921 100644
--- a/doc/pub/Splines/html/Splines-bs.html
+++ b/doc/pub/Splines/html/Splines-bs.html
@@ -79,45 +79,64 @@ Automatically generated HTML file from DocOnce source
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -180,32 +199,45 @@ MathJax.Hub.Config({
      <!-- navigation toc: --> <li><a href="._Splines-bs023.html#___sec22" style="font-size: 80%;">Simple codes for  steepest descent and conjugate gradient using a \( 2\times 2 \) matrix, in c++, Python code to come</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs024.html#___sec23" style="font-size: 80%;">The routine for the steepest descent method</a></li>
      <!-- navigation toc: --> <li><a href="._Splines-bs025.html#___sec24" style="font-size: 80%;">Steepest descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Revisiting our first homework</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Gradient descent example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The Hessian matrix</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">Simple program</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Gradient Descent Example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">Gradient descent and Ridge</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Automatic differentiation</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Using autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Autograd with more complicated functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">More autograd</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">And  with loops</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">Using recursion</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Unsupported functions</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">Recommended to avoid</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Computation of gradients</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">SGD example</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">The gradient step</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">Simple example code</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">When do we stop?</a></li>
-     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs026.html#___sec25" style="font-size: 80%;">Conjugate gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs027.html#___sec26" style="font-size: 80%;">Revisiting our first homework</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs028.html#___sec27" style="font-size: 80%;">Gradient descent example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs029.html#___sec28" style="font-size: 80%;">The derivative of the cost/loss function</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs030.html#___sec29" style="font-size: 80%;">The Hessian matrix</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs031.html#___sec30" style="font-size: 80%;">Simple program</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs032.html#___sec31" style="font-size: 80%;">Gradient Descent Example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs033.html#___sec32" style="font-size: 80%;">And a corresponding example using <b>scikit-learn</b></a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs034.html#___sec33" style="font-size: 80%;">Gradient descent and Ridge</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs035.html#___sec34" style="font-size: 80%;">Automatic differentiation</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs036.html#___sec35" style="font-size: 80%;">Using autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs037.html#___sec36" style="font-size: 80%;">Autograd with more complicated functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs038.html#___sec37" style="font-size: 80%;">More complicated functions using the elements of their arguments directly</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs039.html#___sec38" style="font-size: 80%;">Functions using mathematical functions from Numpy</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs040.html#___sec39" style="font-size: 80%;">More autograd</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs041.html#___sec40" style="font-size: 80%;">And  with loops</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs042.html#___sec41" style="font-size: 80%;">Using recursion</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs043.html#___sec42" style="font-size: 80%;">Unsupported functions</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs044.html#___sec43" style="font-size: 80%;">The syntax a.dot(b) when finding the dot product</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs045.html#___sec44" style="font-size: 80%;">Recommended to avoid</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs046.html#___sec45" style="font-size: 80%;">Stochastic Gradient Descent</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs047.html#___sec46" style="font-size: 80%;">Computation of gradients</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs048.html#___sec47" style="font-size: 80%;">SGD example</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs049.html#___sec48" style="font-size: 80%;">The gradient step</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs050.html#___sec49" style="font-size: 80%;">Simple example code</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs051.html#___sec50" style="font-size: 80%;">When do we stop?</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs052.html#___sec51" style="font-size: 80%;">Slightly different approach</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs053.html#___sec52" style="font-size: 80%;">Program for stochastic gradient</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs054.html#___sec53" style="font-size: 80%;">Momentum based methods</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs055.html#___sec54" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs056.html#___sec55" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs057.html#___sec56" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs058.html#___sec57" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs059.html#___sec58" style="font-size: 80%;">Conjugate gradient method and iterations</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs060.html#___sec59" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs061.html#___sec60" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs062.html#___sec61" style="font-size: 80%;">Conjugate gradient method</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs063.html#___sec62" style="font-size: 80%;">Simple implementation of the Conjugate gradient algorithm</a></li>
+     <!-- navigation toc: --> <li><a href="._Splines-bs064.html#___sec63" style="font-size: 80%;">Broyden–Fletcher–Goldfarb–Shanno algorithm</a></li>
 
         </ul>
       </li>
@@ -240,7 +272,7 @@ MathJax.Hub.Config({
 <center>[2] <b>Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University</b></center>
 <br>
 <p>
-<center><h4>Sep 27, 2018</h4></center> <!-- date -->
+<center><h4>Oct 6, 2018</h4></center> <!-- date -->
 <br>
 <p>
 
@@ -264,7 +296,7 @@ MathJax.Hub.Config({
   <li><a href="._Splines-bs008.html">9</a></li>
   <li><a href="._Splines-bs009.html">10</a></li>
   <li><a href="">...</a></li>
-  <li><a href="._Splines-bs051.html">52</a></li>
+  <li><a href="._Splines-bs064.html">65</a></li>
   <li><a href="._Splines-bs001.html">&raquo;</a></li>
 </ul>
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/Splines-reveal.html b/doc/pub/Splines/html/Splines-reveal.html
index 3c8b4969f..70d6a8a17 100644
--- a/doc/pub/Splines/html/Splines-reveal.html
+++ b/doc/pub/Splines/html/Splines-reveal.html
@@ -148,7 +148,7 @@ MathJax.Hub.Config({
 <center>[2] <b>Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University</b></center>
 <br>
 <p>&nbsp;<br>
-<center><h4>Sep 27, 2018</h4></center> <!-- date -->
+<center><h4>Oct 6, 2018</h4></center> <!-- date -->
 <br>
 <p>
 
@@ -935,7 +935,12 @@ pt.plot(it_array.T[<span style="color: #B452CD">0</span>], it_array.T[<span styl
 
 
 <section>
-<h2 id="___sec25">Revisiting our first homework </h2>
+<h2 id="___sec25">Conjugate gradient </h2>
+</section>
+
+
+<section>
+<h2 id="___sec26">Revisiting our first homework </h2>
 
 <p>
 We will use linear regression as a case study for the gradient descent
@@ -975,7 +980,7 @@ $$
 
 
 <section>
-<h2 id="___sec26">Gradient descent example </h2>
+<h2 id="___sec27">Gradient descent example </h2>
 
 <p>
 Let \( \mathbf{y} = (y_1,\cdots,y_n)^T \), \( \mathbf{\hat{y}} = (\hat{y}_1,\cdots,\hat{y}_n)^T \) and \( \beta = (\beta_0, \beta_1)^T \)
@@ -1004,7 +1009,7 @@ and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
 
 
 <section>
-<h2 id="___sec27">The derivative of the cost/loss function </h2>
+<h2 id="___sec28">The derivative of the cost/loss function </h2>
 
 <p>
 Computing \( \partial C(\beta) / \partial \beta_0 \) and \( \partial C(\beta) / \partial \beta_1 \) we can show  that the gradient can be written as
@@ -1021,7 +1026,7 @@ where \( X \) is the design matrix defined above.
 
 
 <section>
-<h2 id="___sec28">The Hessian matrix </h2>
+<h2 id="___sec29">The Hessian matrix </h2>
 The Hessian matrix of \( C(\beta) \) is given by 
 <p>&nbsp;<br>
 $$
@@ -1037,7 +1042,7 @@ This result implies that \( C(\beta) \) is a convex function since the matrix \(
 
 
 <section>
-<h2 id="___sec29">Simple program </h2>
+<h2 id="___sec30">Simple program </h2>
 
 <p>
 We can now write a program that minimizes \( C(\beta) \) using the gradient descent method with a constant learning rate \( \gamma \) according to 
@@ -1081,7 +1086,7 @@ beta_NE = np.dot(Xt_X_inv,Xt_y)
 
 
 <section>
-<h2 id="___sec30">Gradient Descent Example </h2>
+<h2 id="___sec31">Gradient Descent Example </h2>
 
 <p>
 Another simple example is here
@@ -1131,7 +1136,7 @@ plt.show()
 
 
 <section>
-<h2 id="___sec31">And a corresponding example using <b>scikit-learn</b> </h2>
+<h2 id="___sec32">And a corresponding example using <b>scikit-learn</b> </h2>
 
 <p>
 
@@ -1156,7 +1161,7 @@ sgdreg.fit(x,y.ravel())
 
 
 <section>
-<h2 id="___sec32">Gradient descent and Ridge </h2>
+<h2 id="___sec33">Gradient descent and Ridge </h2>
 
 <p>
 We have also discussed Ridge regression where the loss function contains a regularized given by the \( L_2 \) norm of \( \beta \), 
@@ -1220,7 +1225,7 @@ beta_ridge = np.dot(Z,np.dot(X.T,y))
 
 
 <section>
-<h2 id="___sec33">Automatic differentiation </h2>
+<h2 id="___sec34">Automatic differentiation </h2>
 Python has tools for so-called <b>automatic differentiation</b>.
 Consider the following example
 <p>&nbsp;<br>
@@ -1280,7 +1285,7 @@ plt.show()
 
 
 <section>
-<h2 id="___sec34">Using autograd </h2>
+<h2 id="___sec35">Using autograd </h2>
 
 <p>
 Here we
@@ -1314,7 +1319,7 @@ grad_analytical = <span style="color: #B452CD">3</span>*a**<span style="color: #
 
 
 <section>
-<h2 id="___sec35">Autograd with more complicated functions </h2>
+<h2 id="___sec36">Autograd with more complicated functions </h2>
 
 <p>
 To differentiate with respect to two (or more) arguments of a Python
@@ -1364,7 +1369,7 @@ Note that the grad function will not produce the true gradient of the function.
 
 
 <section>
-<h2 id="___sec36">More complicated functions using the elements of their arguments directly </h2>
+<h2 id="___sec37">More complicated functions using the elements of their arguments directly </h2>
 
 <p>
 
@@ -1398,7 +1403,7 @@ could expect form a gradient-evaluting function.
 
 
 <section>
-<h2 id="___sec37">Functions using mathematical functions from Numpy </h2>
+<h2 id="___sec38">Functions using mathematical functions from Numpy </h2>
 
 <p>
 
@@ -1425,7 +1430,7 @@ f4_grad_analytical = x/np.sqrt(<span style="color: #B452CD">1</span> + x**<span
 
 
 <section>
-<h2 id="___sec38">More autograd </h2>
+<h2 id="___sec39">More autograd </h2>
 
 <p>
 
@@ -1449,7 +1454,7 @@ x = <span style="color: #B452CD">2.7</span>
 
 
 <section>
-<h2 id="___sec39">And  with loops </h2>
+<h2 id="___sec40">And  with loops </h2>
 
 <p>
 
@@ -1496,7 +1501,7 @@ f6_grad_analytical = <span style="color: #B452CD">0</span>
 
 
 <section>
-<h2 id="___sec40">Using recursion </h2>
+<h2 id="___sec41">Using recursion </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
@@ -1534,7 +1539,7 @@ Note that if n is equal to zero or one, Autograd will give an error message. Thi
 
 
 <section>
-<h2 id="___sec41">Unsupported functions </h2>
+<h2 id="___sec42">Unsupported functions </h2>
 Autograd supports many features. However, there are some functions that is not supported (yet) by Autograd.
 
 <p>
@@ -1560,7 +1565,7 @@ Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The
 
 
 <section>
-<h2 id="___sec42">The syntax a.dot(b) when finding the dot product </h2>
+<h2 id="___sec43">The syntax a.dot(b) when finding the dot product </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
@@ -1603,7 +1608,7 @@ x = np.array([<span style="color: #B452CD">3.0</span>,<span style="color: #B452C
 
 
 <section>
-<h2 id="___sec43">Recommended to avoid </h2>
+<h2 id="___sec44">Recommended to avoid </h2>
 The documentation recommends to avoid inplace operations such as
 <p>
 
@@ -1617,7 +1622,7 @@ a /=b
 
 
 <section>
-<h2 id="___sec44">Stochastic Gradient Descent </h2>
+<h2 id="___sec45">Stochastic Gradient Descent </h2>
 
 <p>
 Stochastic gradient descent (SGD) and variants thereof address some of
@@ -1637,7 +1642,7 @@ $$
 
 
 <section>
-<h2 id="___sec45">Computation of gradients </h2>
+<h2 id="___sec46">Computation of gradients </h2>
 
 <p>
 This in turn means that the gradient can be
@@ -1659,7 +1664,7 @@ minibatches. We denote these minibatches by \( B_k \) where
 
 
 <section>
-<h2 id="___sec46">SGD example </h2>
+<h2 id="___sec47">SGD example </h2>
 As an example, suppose we have \( 10 \) data points \( (\mathbf{x}_1,\cdots, \mathbf{x}_{10}) \) 
 and we choose to have \( M=5 \) minibathces,
 then each minibatch contains two data points. In particular we have
@@ -1685,7 +1690,7 @@ $$
 
 
 <section>
-<h2 id="___sec47">The gradient step </h2>
+<h2 id="___sec48">The gradient step </h2>
 
 <p>
 Thus a gradient descent step now looks like 
@@ -1706,7 +1711,7 @@ the number of minibatches, as exemplified in the code below.
 
 
 <section>
-<h2 id="___sec48">Simple example code </h2>
+<h2 id="___sec49">Simple example code </h2>
 
 <p>
 
@@ -1738,7 +1743,7 @@ all \( n \) datapoints.
 
 
 <section>
-<h2 id="___sec49">When do we stop? </h2>
+<h2 id="___sec50">When do we stop? </h2>
 
 <p>
 A natural question is when do we stop the search for a new minimum?
@@ -1755,7 +1760,7 @@ gave the lowest value.
 
 
 <section>
-<h2 id="___sec50">Slightly different approach </h2>
+<h2 id="___sec51">Slightly different approach </h2>
 
 <p>
 Another approach is to let the step length \( \gamma_j \) depend on the
@@ -1805,6 +1810,432 @@ j = <span style="color: #B452CD">0</span>
 </section>
 
 
+<section>
+<h2 id="___sec52">Program for stochastic gradient </h2>
+
+<p>
+
+<!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
+<div class="highlight" style="background: #eeeedd"><pre style="font-size: 80%; line-height: 125%"><span></span><span style="color: #228B22"># Importing various packages</span>
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">math</span> <span style="color: #8B008B; font-weight: bold">import</span> exp, sqrt
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">random</span> <span style="color: #8B008B; font-weight: bold">import</span> random, seed
+<span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">numpy</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">np</span>
+<span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">matplotlib.pyplot</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">plt</span>
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">sklearn.linear_model</span> <span style="color: #8B008B; font-weight: bold">import</span> SGDRegressor
+
+x = <span style="color: #B452CD">2</span>*np.random.rand(<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)
+y = <span style="color: #B452CD">4</span>+<span style="color: #B452CD">3</span>*x+np.random.randn(<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)
+
+xb = np.c_[np.ones((<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)), x]
+theta_linreg = np.linalg.inv(xb.T.dot(xb)).dot(xb.T).dot(y)
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;Own inversion&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta_linreg)
+sgdreg = SGDRegressor(n_iter = <span style="color: #B452CD">50</span>, penalty=<span style="color: #658b00">None</span>, eta0=<span style="color: #B452CD">0.1</span>)
+sgdreg.fit(x,y.ravel())
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;sgdreg from scikit&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(sgdreg.intercept_, sgdreg.coef_)
+
+
+theta = np.random.randn(<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)
+
+eta = <span style="color: #B452CD">0.1</span>
+Niterations = <span style="color: #B452CD">1000</span>
+m = <span style="color: #B452CD">100</span>
+
+<span style="color: #8B008B; font-weight: bold">for</span> <span style="color: #658b00">iter</span> <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(Niterations):
+    gradients = <span style="color: #B452CD">2.0</span>/m*xb.T.dot(xb.dot(theta)-y)
+    theta -= eta*gradients
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;theta frm own gd&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta)
+
+xnew = np.array([[<span style="color: #B452CD">0</span>],[<span style="color: #B452CD">2</span>]])
+xbnew = np.c_[np.ones((<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)), xnew]
+ypredict = xbnew.dot(theta)
+ypredict2 = xbnew.dot(theta_linreg)
+
+
+n_epochs = <span style="color: #B452CD">50</span>
+t0, t1 = <span style="color: #B452CD">5</span>, <span style="color: #B452CD">50</span>
+m = <span style="color: #B452CD">100</span>
+<span style="color: #8B008B; font-weight: bold">def</span> <span style="color: #008b45">learning_schedule</span>(t):
+    <span style="color: #8B008B; font-weight: bold">return</span> t0/(t+t1)
+
+theta = np.random.randn(<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)
+
+<span style="color: #8B008B; font-weight: bold">for</span> epoch <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(n_epochs):
+    <span style="color: #8B008B; font-weight: bold">for</span> i <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(m):
+        random_index = np.random.randint(m)
+        xi = xb[random_index:random_index+<span style="color: #B452CD">1</span>]
+        yi = y[random_index:random_index+<span style="color: #B452CD">1</span>]
+        gradients = <span style="color: #B452CD">2</span> * xi.T.dot(xi.dot(theta)-yi)
+        eta = learning_schedule(epoch*m+i)
+        theta = theta - eta*gradients
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;theta from own sdg&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta)
+
+
+
+
+
+
+plt.plot(xnew, ypredict, <span style="color: #CD5555">&quot;r-&quot;</span>)
+plt.plot(xnew, ypredict2, <span style="color: #CD5555">&quot;b-&quot;</span>)
+plt.plot(x, y ,<span style="color: #CD5555">&#39;ro&#39;</span>)
+plt.axis([<span style="color: #B452CD">0</span>,<span style="color: #B452CD">2.0</span>,<span style="color: #B452CD">0</span>, <span style="color: #B452CD">15.0</span>])
+plt.xlabel(<span style="color: #CD5555">r&#39;$x$&#39;</span>)
+plt.ylabel(<span style="color: #CD5555">r&#39;$y$&#39;</span>)
+plt.title(<span style="color: #CD5555">r&#39;Random numbers &#39;</span>)
+plt.show()
+</pre></div>
+</section>
+
+
+<section>
+<h2 id="___sec53">Momentum based methods </h2>
+</section>
+
+
+<section>
+<h2 id="___sec54">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+In the CG method we define so-called conjugate directions and two vectors 
+\( \hat{s} \) and \( \hat{t} \)
+are said to be
+conjugate if
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{s}^T\hat{A}\hat{t}= 0.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+The philosophy of the CG method is to perform searches in various conjugate directions
+of our vectors \( \hat{x}_i \) obeying the above criterion, namely
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{x}_i^T\hat{A}\hat{x}_j= 0.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+Two vectors are conjugate if they are orthogonal with respect to 
+this inner product. Being conjugate is a symmetric relation: if \( \hat{s} \) is conjugate to \( \hat{t} \), then \( \hat{t} \) is conjugate to \( \hat{s} \).
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec55">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+An example is given by the eigenvectors of the matrix
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{v}_i^T\hat{A}\hat{v}_j= \lambda\hat{v}_i^T\hat{v}_j,
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+which is zero unless \( i=j \).
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec56">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Assume now that we have a symmetric positive-definite matrix \( \hat{A} \) of size
+\( n\times n \). At each iteration \( i+1 \) we obtain the conjugate direction of a vector
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{x}_{i+1}=\hat{x}_{i}+\alpha_i\hat{p}_{i}. 
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+We assume that \( \hat{p}_{i} \) is a sequence of \( n \) mutually conjugate directions. 
+Then the \( \hat{p}_{i} \)  form a basis of \( R^n \) and we can expand the solution 
+$  \hat{A}\hat{x} = \hat{b}$ in this basis, namely
+
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+  \hat{x}  = \sum^{n}_{i=1} \alpha_i \hat{p}_i.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec57">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The coefficients are given by
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+    \mathbf{A}\mathbf{x} = \sum^{n}_{i=1} \alpha_i \mathbf{A} \mathbf{p}_i = \mathbf{b}.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+Multiplying with \( \hat{p}_k^T \)  from the left gives
+
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+  \hat{p}_k^T \hat{A}\hat{x} = \sum^{n}_{i=1} \alpha_i\hat{p}_k^T \hat{A}\hat{p}_i= \hat{p}_k^T \hat{b},
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+and we can define the coefficients \( \alpha_k \) as
+
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+    \alpha_k = \frac{\hat{p}_k^T \hat{b}}{\hat{p}_k^T \hat{A} \hat{p}_k}
+\end{equation*}
+$$
+<p>&nbsp;<br>
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec58">Conjugate gradient method and iterations </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+If we choose the conjugate vectors \( \hat{p}_k \) carefully, 
+then we may not need all of them to obtain a good approximation to the solution 
+\( \hat{x} \). 
+We want to regard the conjugate gradient method as an iterative method. 
+This will us to solve systems where \( n \) is so large that the direct 
+method would take too much time.
+
+<p>
+We denote the initial guess for \( \hat{x} \) as \( \hat{x}_0 \). 
+We can assume without loss of generality that
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{x}_0=0,
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+or consider the system
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{A}\hat{z} = \hat{b}-\hat{A}\hat{x}_0,
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+instead.
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec59">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+One can show that the solution \( \hat{x} \) is also the unique minimizer of the quadratic form
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+  f(\hat{x}) = \frac{1}{2}\hat{x}^T\hat{A}\hat{x} - \hat{x}^T \hat{x} , \quad \hat{x}\in\mathbf{R}^n. 
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+This suggests taking the first basis vector \( \hat{p}_1 \) 
+to be the gradient of \( f \) at \( \hat{x}=\hat{x}_0 \), 
+which equals
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{A}\hat{x}_0-\hat{b},
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+and 
+\( \hat{x}_0=0 \) it is equal \( -\hat{b} \).
+The other vectors in the basis will be conjugate to the gradient, 
+hence the name conjugate gradient method.
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec60">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Let  \( \hat{r}_k \) be the residual at the \( k \)-th step:
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{r}_k=\hat{b}-\hat{A}\hat{x}_k.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+
+Note that \( \hat{r}_k \) is the negative gradient of \( f \) at 
+\( \hat{x}=\hat{x}_k \), 
+so the gradient descent method would be to move in the direction \( \hat{r}_k \). 
+Here, we insist that the directions \( \hat{p}_k \) are conjugate to each other, 
+so we take the direction closest to the gradient \( \hat{r}_k \)  
+under the conjugacy constraint. 
+This gives the following expression
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{p}_{k+1}=\hat{r}_k-\frac{\hat{p}_k^T \hat{A}\hat{r}_k}{\hat{p}_k^T\hat{A}\hat{p}_k} \hat{p}_k.
+\end{equation*}
+$$
+<p>&nbsp;<br>
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec61">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+We can also  compute the residual iteratively as
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{b}-\hat{A}\hat{x}_{k+1},
+ \end{equation*}
+$$
+<p>&nbsp;<br>
+
+which equals
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{b}-\hat{A}(\hat{x}_k+\alpha_k\hat{p}_k),
+ \end{equation*}
+$$
+<p>&nbsp;<br>
+
+or
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+(\hat{b}-\hat{A}\hat{x}_k)-\alpha_k\hat{A}\hat{p}_k,
+ \end{equation*}
+$$
+<p>&nbsp;<br>
+
+which gives
+
+<p>&nbsp;<br>
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{r}_k-\hat{A}\hat{p}_{k},
+ \end{equation*}
+$$
+<p>&nbsp;<br>
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec62">Simple implementation of the Conjugate gradient algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+
+<!-- code=c++ (!bc cppcod) typeset with pygments style "perldoc" -->
+<div class="highlight" style="background: #eeeedd"><pre style="font-size: 80%; line-height: 125%"><span></span>  Vector <span style="color: #008b45">ConjugateGradient</span>(Matrix A, Vector b, Vector x0){
+  <span style="color: #00688B; font-weight: bold">int</span> dim = x0.Dimension();
+  <span style="color: #8B008B; font-weight: bold">const</span> <span style="color: #00688B; font-weight: bold">double</span> tolerance = <span style="color: #B452CD">1.0e-14</span>;
+  Vector x(dim),r(dim),v(dim),z(dim);
+  <span style="color: #00688B; font-weight: bold">double</span> c,t,d;
+
+  x = x0;
+  r = b - A*x;
+  v = r;
+  c = dot(r,r);
+  <span style="color: #00688B; font-weight: bold">int</span> i = <span style="color: #B452CD">0</span>; IterMax = dim;
+  <span style="color: #8B008B; font-weight: bold">while</span>(i &lt;= IterMax){
+    z = A*v;
+    t = c/dot(v,z);
+    x = x + t*v;
+    r = r - t*z;
+    d = dot(r,r);
+    <span style="color: #8B008B; font-weight: bold">if</span>(sqrt(d) &lt; tolerance)
+      <span style="color: #8B008B; font-weight: bold">break</span>;
+    v = r + (d/c)*v;
+    c = d;  i++;
+  }
+  <span style="color: #8B008B; font-weight: bold">return</span> x;
+} 
+</pre></div>
+
+</div>
+</section>
+
+
+<section>
+<h2 id="___sec63">Broyden&#8211;Fletcher&#8211;Goldfarb&#8211;Shanno algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The optimization problem is to minimize \( f(\mathbf {x} ) \) where \( \mathbf {x} \)  is a vector in \( R^{n} \), and \( f \) is a differentiable scalar function. There are no constraints on the values that  \( \mathbf {x} \)  can take.
+
+<p>
+The algorithm begins at an initial estimate for the optimal value \( \mathbf {x}_{0} \) and proceeds iteratively to get a better estimate at each stage.
+
+<p>
+The search direction \( p_k \) at stage \( k \) is given by the solution of the analogue of the Newton equation
+<p>&nbsp;<br>
+$$
+B_{k}\mathbf {p} _{k}=-\nabla f(\mathbf {x}_{k}),
+$$
+<p>&nbsp;<br>
+
+<p>
+where \( B_{k} \) is an approximation to the Hessian matrix, which is
+updated iteratively at each stage, and \( \nabla f(\mathbf {x} _{k}) \)
+is the gradient of the function
+evaluated at \( x_k \). 
+A line search in the direction \( p_k \) is then used to
+find the next point \( x_{k+1} \) by minimising 
+<p>&nbsp;<br>
+$$
+f(\mathbf {x}_{k}+\alpha \mathbf {p}_{k}),
+$$
+<p>&nbsp;<br>
+
+over the scalar \( \alpha > 0 \).
+
+
+</div>
+</section>
+
+
 
 </div> <!-- class="slides" -->
 </div> <!-- class="reveal" -->
diff --git a/doc/pub/Splines/html/Splines-solarized.html b/doc/pub/Splines/html/Splines-solarized.html
index 31978caf3..aaddf1a72 100644
--- a/doc/pub/Splines/html/Splines-solarized.html
+++ b/doc/pub/Splines/html/Splines-solarized.html
@@ -99,45 +99,64 @@ div { text-align: justify; text-justify: inter-word; }
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -179,7 +198,7 @@ MathJax.Hub.Config({
 <center>[2] <b>Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University</b></center>
 <br>
 <p>
-<center><h4>Sep 27, 2018</h4></center> <!-- date -->
+<center><h4>Oct 6, 2018</h4></center> <!-- date -->
 <br>
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
@@ -905,10 +924,15 @@ pt.contour(xmesh, ymesh, fmesh, <span style="color: #B452CD">50</span>)
 it_array = np.array(guesses)
 pt.plot(it_array.T[<span style="color: #B452CD">0</span>], it_array.T[<span style="color: #B452CD">1</span>], <span style="color: #CD5555">&quot;x-&quot;</span>)
 </pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec25">Conjugate gradient </h2>
+
 <p>
 <!-- !split  -->
 
-<h2 id="___sec25">Revisiting our first homework </h2>
+<h2 id="___sec26">Revisiting our first homework </h2>
 
 <p>
 We will use linear regression as a case study for the gradient descent
@@ -941,7 +965,7 @@ $$
 <p>
 <!-- !split  -->
 
-<h2 id="___sec26">Gradient descent example </h2>
+<h2 id="___sec27">Gradient descent example </h2>
 
 <p>
 Let \( \mathbf{y} = (y_1,\cdots,y_n)^T \), \( \mathbf{\hat{y}} = (\hat{y}_1,\cdots,\hat{y}_n)^T \) and \( \beta = (\beta_0, \beta_1)^T \)
@@ -966,7 +990,7 @@ and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec27">The derivative of the cost/loss function </h2>
+<h2 id="___sec28">The derivative of the cost/loss function </h2>
 
 <p>
 Computing \( \partial C(\beta) / \partial \beta_0 \) and \( \partial C(\beta) / \partial \beta_1 \) we can show  that the gradient can be written as
@@ -981,7 +1005,7 @@ where \( X \) is the design matrix defined above.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec28">The Hessian matrix </h2>
+<h2 id="___sec29">The Hessian matrix </h2>
 The Hessian matrix of \( C(\beta) \) is given by 
 $$
 \hat{H} \equiv \begin{bmatrix}
@@ -995,7 +1019,7 @@ This result implies that \( C(\beta) \) is a convex function since the matrix \(
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec29">Simple program </h2>
+<h2 id="___sec30">Simple program </h2>
 
 <p>
 We can now write a program that minimizes \( C(\beta) \) using the gradient descent method with a constant learning rate \( \gamma \) according to 
@@ -1036,7 +1060,7 @@ beta_NE = np.dot(Xt_X_inv,Xt_y)
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec30">Gradient Descent Example </h2>
+<h2 id="___sec31">Gradient Descent Example </h2>
 
 <p>
 Another simple example is here
@@ -1085,7 +1109,7 @@ plt.show()
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec31">And a corresponding example using <b>scikit-learn</b> </h2>
+<h2 id="___sec32">And a corresponding example using <b>scikit-learn</b> </h2>
 
 <p>
 
@@ -1109,7 +1133,7 @@ sgdreg.fit(x,y.ravel())
 <p>
 <!-- !split  -->
 
-<h2 id="___sec32">Gradient descent and Ridge </h2>
+<h2 id="___sec33">Gradient descent and Ridge </h2>
 
 <p>
 We have also discussed Ridge regression where the loss function contains a regularized given by the \( L_2 \) norm of \( \beta \), 
@@ -1166,7 +1190,7 @@ beta_ridge = np.dot(Z,np.dot(X.T,y))
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec33">Automatic differentiation </h2>
+<h2 id="___sec34">Automatic differentiation </h2>
 Python has tools for so-called <b>automatic differentiation</b>.
 Consider the following example
 $$
@@ -1221,7 +1245,7 @@ plt.show()
 <p>
 <!-- !split  -->
 
-<h2 id="___sec34">Using autograd </h2>
+<h2 id="___sec35">Using autograd </h2>
 
 <p>
 Here we
@@ -1254,7 +1278,7 @@ grad_analytical = <span style="color: #B452CD">3</span>*a**<span style="color: #
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec35">Autograd with more complicated functions </h2>
+<h2 id="___sec36">Autograd with more complicated functions </h2>
 
 <p>
 To differentiate with respect to two (or more) arguments of a Python
@@ -1304,7 +1328,7 @@ Note that the grad function will not produce the true gradient of the function.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec36">More complicated functions using the elements of their arguments directly </h2>
+<h2 id="___sec37">More complicated functions using the elements of their arguments directly </h2>
 
 <p>
 
@@ -1338,7 +1362,7 @@ could expect form a gradient-evaluting function.
 <p>
 <!-- !split  -->
 
-<h2 id="___sec37">Functions using mathematical functions from Numpy </h2>
+<h2 id="___sec38">Functions using mathematical functions from Numpy </h2>
 
 <p>
 
@@ -1364,7 +1388,7 @@ f4_grad_analytical = x/np.sqrt(<span style="color: #B452CD">1</span> + x**<span
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec38">More autograd </h2>
+<h2 id="___sec39">More autograd </h2>
 
 <p>
 
@@ -1387,7 +1411,7 @@ x = <span style="color: #B452CD">2.7</span>
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec39">And  with loops </h2>
+<h2 id="___sec40">And  with loops </h2>
 
 <p>
 
@@ -1433,7 +1457,7 @@ f6_grad_analytical = <span style="color: #B452CD">0</span>
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec40">Using recursion </h2>
+<h2 id="___sec41">Using recursion </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
@@ -1471,7 +1495,7 @@ Note that if n is equal to zero or one, Autograd will give an error message. Thi
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec41">Unsupported functions </h2>
+<h2 id="___sec42">Unsupported functions </h2>
 Autograd supports many features. However, there are some functions that is not supported (yet) by Autograd.
 
 <p>
@@ -1497,7 +1521,7 @@ Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec42">The syntax a.dot(b) when finding the dot product </h2>
+<h2 id="___sec43">The syntax a.dot(b) when finding the dot product </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
@@ -1539,7 +1563,7 @@ x = np.array([<span style="color: #B452CD">3.0</span>,<span style="color: #B452C
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec43">Recommended to avoid </h2>
+<h2 id="___sec44">Recommended to avoid </h2>
 The documentation recommends to avoid inplace operations such as
 <p>
 
@@ -1552,7 +1576,7 @@ a /=b
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec44">Stochastic Gradient Descent </h2>
+<h2 id="___sec45">Stochastic Gradient Descent </h2>
 
 <p>
 Stochastic gradient descent (SGD) and variants thereof address some of
@@ -1570,7 +1594,7 @@ $$
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec45">Computation of gradients </h2>
+<h2 id="___sec46">Computation of gradients </h2>
 
 <p>
 This in turn means that the gradient can be
@@ -1590,7 +1614,7 @@ minibatches. We denote these minibatches by \( B_k \) where
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec46">SGD example </h2>
+<h2 id="___sec47">SGD example </h2>
 As an example, suppose we have \( 10 \) data points \( (\mathbf{x}_1,\cdots, \mathbf{x}_{10}) \) 
 and we choose to have \( M=5 \) minibathces,
 then each minibatch contains two data points. In particular we have
@@ -1614,7 +1638,7 @@ $$
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec47">The gradient step </h2>
+<h2 id="___sec48">The gradient step </h2>
 
 <p>
 Thus a gradient descent step now looks like 
@@ -1633,7 +1657,7 @@ the number of minibatches, as exemplified in the code below.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec48">Simple example code </h2>
+<h2 id="___sec49">Simple example code </h2>
 
 <p>
 
@@ -1665,7 +1689,7 @@ all \( n \) datapoints.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec49">When do we stop? </h2>
+<h2 id="___sec50">When do we stop? </h2>
 
 <p>
 A natural question is when do we stop the search for a new minimum?
@@ -1682,7 +1706,7 @@ gave the lowest value.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec50">Slightly different approach </h2>
+<h2 id="___sec51">Slightly different approach </h2>
 
 <p>
 Another approach is to let the step length \( \gamma_j \) depend on the
@@ -1727,6 +1751,404 @@ j = <span style="color: #B452CD">0</span>
 
 <span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;gamma_j after %d epochs: %g&quot;</span> % (n_epochs,gamma_j))
 </pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec52">Program for stochastic gradient </h2>
+
+<p>
+
+<!-- code=python (!bc pycod) typeset with pygments style "perldoc" -->
+<div class="highlight" style="background: #eeeedd"><pre style="line-height: 125%"><span></span><span style="color: #228B22"># Importing various packages</span>
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">math</span> <span style="color: #8B008B; font-weight: bold">import</span> exp, sqrt
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">random</span> <span style="color: #8B008B; font-weight: bold">import</span> random, seed
+<span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">numpy</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">np</span>
+<span style="color: #8B008B; font-weight: bold">import</span> <span style="color: #008b45; text-decoration: underline">matplotlib.pyplot</span> <span style="color: #8B008B; font-weight: bold">as</span> <span style="color: #008b45; text-decoration: underline">plt</span>
+<span style="color: #8B008B; font-weight: bold">from</span> <span style="color: #008b45; text-decoration: underline">sklearn.linear_model</span> <span style="color: #8B008B; font-weight: bold">import</span> SGDRegressor
+
+x = <span style="color: #B452CD">2</span>*np.random.rand(<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)
+y = <span style="color: #B452CD">4</span>+<span style="color: #B452CD">3</span>*x+np.random.randn(<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)
+
+xb = np.c_[np.ones((<span style="color: #B452CD">100</span>,<span style="color: #B452CD">1</span>)), x]
+theta_linreg = np.linalg.inv(xb.T.dot(xb)).dot(xb.T).dot(y)
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;Own inversion&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta_linreg)
+sgdreg = SGDRegressor(n_iter = <span style="color: #B452CD">50</span>, penalty=<span style="color: #658b00">None</span>, eta0=<span style="color: #B452CD">0.1</span>)
+sgdreg.fit(x,y.ravel())
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;sgdreg from scikit&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(sgdreg.intercept_, sgdreg.coef_)
+
+
+theta = np.random.randn(<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)
+
+eta = <span style="color: #B452CD">0.1</span>
+Niterations = <span style="color: #B452CD">1000</span>
+m = <span style="color: #B452CD">100</span>
+
+<span style="color: #8B008B; font-weight: bold">for</span> <span style="color: #658b00">iter</span> <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(Niterations):
+    gradients = <span style="color: #B452CD">2.0</span>/m*xb.T.dot(xb.dot(theta)-y)
+    theta -= eta*gradients
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;theta frm own gd&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta)
+
+xnew = np.array([[<span style="color: #B452CD">0</span>],[<span style="color: #B452CD">2</span>]])
+xbnew = np.c_[np.ones((<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)), xnew]
+ypredict = xbnew.dot(theta)
+ypredict2 = xbnew.dot(theta_linreg)
+
+
+n_epochs = <span style="color: #B452CD">50</span>
+t0, t1 = <span style="color: #B452CD">5</span>, <span style="color: #B452CD">50</span>
+m = <span style="color: #B452CD">100</span>
+<span style="color: #8B008B; font-weight: bold">def</span> <span style="color: #008b45">learning_schedule</span>(t):
+    <span style="color: #8B008B; font-weight: bold">return</span> t0/(t+t1)
+
+theta = np.random.randn(<span style="color: #B452CD">2</span>,<span style="color: #B452CD">1</span>)
+
+<span style="color: #8B008B; font-weight: bold">for</span> epoch <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(n_epochs):
+    <span style="color: #8B008B; font-weight: bold">for</span> i <span style="color: #8B008B">in</span> <span style="color: #658b00">range</span>(m):
+        random_index = np.random.randint(m)
+        xi = xb[random_index:random_index+<span style="color: #B452CD">1</span>]
+        yi = y[random_index:random_index+<span style="color: #B452CD">1</span>]
+        gradients = <span style="color: #B452CD">2</span> * xi.T.dot(xi.dot(theta)-yi)
+        eta = learning_schedule(epoch*m+i)
+        theta = theta - eta*gradients
+<span style="color: #8B008B; font-weight: bold">print</span>(<span style="color: #CD5555">&quot;theta from own sdg&quot;</span>)
+<span style="color: #8B008B; font-weight: bold">print</span>(theta)
+
+
+
+
+
+
+plt.plot(xnew, ypredict, <span style="color: #CD5555">&quot;r-&quot;</span>)
+plt.plot(xnew, ypredict2, <span style="color: #CD5555">&quot;b-&quot;</span>)
+plt.plot(x, y ,<span style="color: #CD5555">&#39;ro&#39;</span>)
+plt.axis([<span style="color: #B452CD">0</span>,<span style="color: #B452CD">2.0</span>,<span style="color: #B452CD">0</span>, <span style="color: #B452CD">15.0</span>])
+plt.xlabel(<span style="color: #CD5555">r&#39;$x$&#39;</span>)
+plt.ylabel(<span style="color: #CD5555">r&#39;$y$&#39;</span>)
+plt.title(<span style="color: #CD5555">r&#39;Random numbers &#39;</span>)
+plt.show()
+</pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec53">Momentum based methods </h2>
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec54">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+In the CG method we define so-called conjugate directions and two vectors 
+\( \hat{s} \) and \( \hat{t} \)
+are said to be
+conjugate if
+$$
+\begin{equation*}
+\hat{s}^T\hat{A}\hat{t}= 0.
+\end{equation*}
+$$
+
+The philosophy of the CG method is to perform searches in various conjugate directions
+of our vectors \( \hat{x}_i \) obeying the above criterion, namely
+$$
+\begin{equation*}
+\hat{x}_i^T\hat{A}\hat{x}_j= 0.
+\end{equation*}
+$$
+
+Two vectors are conjugate if they are orthogonal with respect to 
+this inner product. Being conjugate is a symmetric relation: if \( \hat{s} \) is conjugate to \( \hat{t} \), then \( \hat{t} \) is conjugate to \( \hat{s} \).
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec55">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+An example is given by the eigenvectors of the matrix
+$$
+\begin{equation*}
+\hat{v}_i^T\hat{A}\hat{v}_j= \lambda\hat{v}_i^T\hat{v}_j,
+\end{equation*}
+$$
+
+which is zero unless \( i=j \).
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec56">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Assume now that we have a symmetric positive-definite matrix \( \hat{A} \) of size
+\( n\times n \). At each iteration \( i+1 \) we obtain the conjugate direction of a vector
+$$
+\begin{equation*}
+\hat{x}_{i+1}=\hat{x}_{i}+\alpha_i\hat{p}_{i}. 
+\end{equation*}
+$$
+
+We assume that \( \hat{p}_{i} \) is a sequence of \( n \) mutually conjugate directions. 
+Then the \( \hat{p}_{i} \)  form a basis of \( R^n \) and we can expand the solution 
+$  \hat{A}\hat{x} = \hat{b}$ in this basis, namely
+
+$$
+\begin{equation*}
+  \hat{x}  = \sum^{n}_{i=1} \alpha_i \hat{p}_i.
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec57">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The coefficients are given by
+$$
+\begin{equation*}
+    \mathbf{A}\mathbf{x} = \sum^{n}_{i=1} \alpha_i \mathbf{A} \mathbf{p}_i = \mathbf{b}.
+\end{equation*}
+$$
+
+Multiplying with \( \hat{p}_k^T \)  from the left gives
+
+$$
+\begin{equation*}
+  \hat{p}_k^T \hat{A}\hat{x} = \sum^{n}_{i=1} \alpha_i\hat{p}_k^T \hat{A}\hat{p}_i= \hat{p}_k^T \hat{b},
+\end{equation*}
+$$
+
+and we can define the coefficients \( \alpha_k \) as
+
+$$
+\begin{equation*}
+    \alpha_k = \frac{\hat{p}_k^T \hat{b}}{\hat{p}_k^T \hat{A} \hat{p}_k}
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec58">Conjugate gradient method and iterations </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+
+<p>
+If we choose the conjugate vectors \( \hat{p}_k \) carefully, 
+then we may not need all of them to obtain a good approximation to the solution 
+\( \hat{x} \). 
+We want to regard the conjugate gradient method as an iterative method. 
+This will us to solve systems where \( n \) is so large that the direct 
+method would take too much time.
+
+<p>
+We denote the initial guess for \( \hat{x} \) as \( \hat{x}_0 \). 
+We can assume without loss of generality that
+$$
+\begin{equation*}
+\hat{x}_0=0,
+\end{equation*}
+$$
+
+or consider the system
+$$
+\begin{equation*}
+\hat{A}\hat{z} = \hat{b}-\hat{A}\hat{x}_0,
+\end{equation*}
+$$
+
+instead.
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec59">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+One can show that the solution \( \hat{x} \) is also the unique minimizer of the quadratic form
+$$
+\begin{equation*}
+  f(\hat{x}) = \frac{1}{2}\hat{x}^T\hat{A}\hat{x} - \hat{x}^T \hat{x} , \quad \hat{x}\in\mathbf{R}^n. 
+\end{equation*}
+$$
+
+This suggests taking the first basis vector \( \hat{p}_1 \) 
+to be the gradient of \( f \) at \( \hat{x}=\hat{x}_0 \), 
+which equals
+$$
+\begin{equation*}
+\hat{A}\hat{x}_0-\hat{b},
+\end{equation*}
+$$
+
+and 
+\( \hat{x}_0=0 \) it is equal \( -\hat{b} \).
+The other vectors in the basis will be conjugate to the gradient, 
+hence the name conjugate gradient method.
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec60">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Let  \( \hat{r}_k \) be the residual at the \( k \)-th step:
+$$
+\begin{equation*}
+\hat{r}_k=\hat{b}-\hat{A}\hat{x}_k.
+\end{equation*}
+$$
+
+Note that \( \hat{r}_k \) is the negative gradient of \( f \) at 
+\( \hat{x}=\hat{x}_k \), 
+so the gradient descent method would be to move in the direction \( \hat{r}_k \). 
+Here, we insist that the directions \( \hat{p}_k \) are conjugate to each other, 
+so we take the direction closest to the gradient \( \hat{r}_k \)  
+under the conjugacy constraint. 
+This gives the following expression
+$$
+\begin{equation*}
+\hat{p}_{k+1}=\hat{r}_k-\frac{\hat{p}_k^T \hat{A}\hat{r}_k}{\hat{p}_k^T\hat{A}\hat{p}_k} \hat{p}_k.
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec61">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+We can also  compute the residual iteratively as
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{b}-\hat{A}\hat{x}_{k+1},
+ \end{equation*}
+$$
+
+which equals
+$$
+\begin{equation*}
+\hat{b}-\hat{A}(\hat{x}_k+\alpha_k\hat{p}_k),
+ \end{equation*}
+$$
+
+or
+$$
+\begin{equation*}
+(\hat{b}-\hat{A}\hat{x}_k)-\alpha_k\hat{A}\hat{p}_k,
+ \end{equation*}
+$$
+
+which gives
+
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{r}_k-\hat{A}\hat{p}_{k},
+ \end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec62">Simple implementation of the Conjugate gradient algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+<p>
+
+<!-- code=c++ (!bc cppcod) typeset with pygments style "perldoc" -->
+<div class="highlight" style="background: #eee8d5"><pre style="line-height: 125%"><span></span>  Vector <span style="color: #008b45">ConjugateGradient</span>(Matrix A, Vector b, Vector x0){
+  <span style="color: #00688B; font-weight: bold">int</span> dim = x0.Dimension();
+  <span style="color: #8B008B; font-weight: bold">const</span> <span style="color: #00688B; font-weight: bold">double</span> tolerance = <span style="color: #B452CD">1.0e-14</span>;
+  Vector x(dim),r(dim),v(dim),z(dim);
+  <span style="color: #00688B; font-weight: bold">double</span> c,t,d;
+
+  x = x0;
+  r = b - A*x;
+  v = r;
+  c = dot(r,r);
+  <span style="color: #00688B; font-weight: bold">int</span> i = <span style="color: #B452CD">0</span>; IterMax = dim;
+  <span style="color: #8B008B; font-weight: bold">while</span>(i &lt;= IterMax){
+    z = A*v;
+    t = c/dot(v,z);
+    x = x + t*v;
+    r = r - t*z;
+    d = dot(r,r);
+    <span style="color: #8B008B; font-weight: bold">if</span>(sqrt(d) &lt; tolerance)
+      <span style="color: #8B008B; font-weight: bold">break</span>;
+    v = r + (d/c)*v;
+    c = d;  i++;
+  }
+  <span style="color: #8B008B; font-weight: bold">return</span> x;
+} 
+</pre></div>
+
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec63">Broyden&#8211;Fletcher&#8211;Goldfarb&#8211;Shanno algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The optimization problem is to minimize \( f(\mathbf {x} ) \) where \( \mathbf {x} \)  is a vector in \( R^{n} \), and \( f \) is a differentiable scalar function. There are no constraints on the values that  \( \mathbf {x} \)  can take.
+
+<p>
+The algorithm begins at an initial estimate for the optimal value \( \mathbf {x}_{0} \) and proceeds iteratively to get a better estimate at each stage.
+
+<p>
+The search direction \( p_k \) at stage \( k \) is given by the solution of the analogue of the Newton equation
+$$
+B_{k}\mathbf {p} _{k}=-\nabla f(\mathbf {x}_{k}),
+$$
+
+<p>
+where \( B_{k} \) is an approximation to the Hessian matrix, which is
+updated iteratively at each stage, and \( \nabla f(\mathbf {x} _{k}) \)
+is the gradient of the function
+evaluated at \( x_k \). 
+A line search in the direction \( p_k \) is then used to
+find the next point \( x_{k+1} \) by minimising 
+$$
+f(\mathbf {x}_{k}+\alpha \mathbf {p}_{k}),
+$$
+
+over the scalar \( \alpha > 0 \).
+
+
+</div>
+
+
 <p>
 
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/html/Splines.html b/doc/pub/Splines/html/Splines.html
index a8cc120b7..31883185d 100644
--- a/doc/pub/Splines/html/Splines.html
+++ b/doc/pub/Splines/html/Splines.html
@@ -104,45 +104,64 @@ div { text-align: justify; text-justify: inter-word; }
                None,
                '___sec23'),
               ('Steepest descent example', 2, None, '___sec24'),
-              ('Revisiting our first homework', 2, None, '___sec25'),
-              ('Gradient descent example', 2, None, '___sec26'),
-              ('The derivative of the cost/loss function', 2, None, '___sec27'),
-              ('The Hessian matrix', 2, None, '___sec28'),
-              ('Simple program', 2, None, '___sec29'),
-              ('Gradient Descent Example', 2, None, '___sec30'),
+              ('Conjugate gradient', 2, None, '___sec25'),
+              ('Revisiting our first homework', 2, None, '___sec26'),
+              ('Gradient descent example', 2, None, '___sec27'),
+              ('The derivative of the cost/loss function', 2, None, '___sec28'),
+              ('The Hessian matrix', 2, None, '___sec29'),
+              ('Simple program', 2, None, '___sec30'),
+              ('Gradient Descent Example', 2, None, '___sec31'),
               ('And a corresponding example using _scikit-learn_',
                2,
                None,
-               '___sec31'),
-              ('Gradient descent and Ridge', 2, None, '___sec32'),
-              ('Automatic differentiation', 2, None, '___sec33'),
-              ('Using autograd', 2, None, '___sec34'),
-              ('Autograd with more complicated functions', 2, None, '___sec35'),
+               '___sec32'),
+              ('Gradient descent and Ridge', 2, None, '___sec33'),
+              ('Automatic differentiation', 2, None, '___sec34'),
+              ('Using autograd', 2, None, '___sec35'),
+              ('Autograd with more complicated functions', 2, None, '___sec36'),
               ('More complicated functions using the elements of their '
                'arguments directly',
                2,
                None,
-               '___sec36'),
+               '___sec37'),
               ('Functions using mathematical functions from Numpy',
                2,
                None,
-               '___sec37'),
-              ('More autograd', 2, None, '___sec38'),
-              ('And  with loops', 2, None, '___sec39'),
-              ('Using recursion', 2, None, '___sec40'),
-              ('Unsupported functions', 2, None, '___sec41'),
+               '___sec38'),
+              ('More autograd', 2, None, '___sec39'),
+              ('And  with loops', 2, None, '___sec40'),
+              ('Using recursion', 2, None, '___sec41'),
+              ('Unsupported functions', 2, None, '___sec42'),
               ('The syntax a.dot(b) when finding the dot product',
                2,
                None,
-               '___sec42'),
-              ('Recommended to avoid', 2, None, '___sec43'),
-              ('Stochastic Gradient Descent', 2, None, '___sec44'),
-              ('Computation of gradients', 2, None, '___sec45'),
-              ('SGD example', 2, None, '___sec46'),
-              ('The gradient step', 2, None, '___sec47'),
-              ('Simple example code', 2, None, '___sec48'),
-              ('When do we stop?', 2, None, '___sec49'),
-              ('Slightly different approach', 2, None, '___sec50')]}
+               '___sec43'),
+              ('Recommended to avoid', 2, None, '___sec44'),
+              ('Stochastic Gradient Descent', 2, None, '___sec45'),
+              ('Computation of gradients', 2, None, '___sec46'),
+              ('SGD example', 2, None, '___sec47'),
+              ('The gradient step', 2, None, '___sec48'),
+              ('Simple example code', 2, None, '___sec49'),
+              ('When do we stop?', 2, None, '___sec50'),
+              ('Slightly different approach', 2, None, '___sec51'),
+              ('Program for stochastic gradient', 2, None, '___sec52'),
+              ('Momentum based methods', 2, None, '___sec53'),
+              ('Conjugate gradient method', 2, None, '___sec54'),
+              ('Conjugate gradient method', 2, None, '___sec55'),
+              ('Conjugate gradient method', 2, None, '___sec56'),
+              ('Conjugate gradient method', 2, None, '___sec57'),
+              ('Conjugate gradient method and iterations', 2, None, '___sec58'),
+              ('Conjugate gradient method', 2, None, '___sec59'),
+              ('Conjugate gradient method', 2, None, '___sec60'),
+              ('Conjugate gradient method', 2, None, '___sec61'),
+              ('Simple implementation of the Conjugate gradient algorithm',
+               2,
+               None,
+               '___sec62'),
+              ('Broyden–Fletcher–Goldfarb–Shanno algorithm',
+               2,
+               None,
+               '___sec63')]}
 end of tocinfo -->
 
 <body>
@@ -184,7 +203,7 @@ MathJax.Hub.Config({
 <center>[2] <b>Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University</b></center>
 <br>
 <p>
-<center><h4>Sep 27, 2018</h4></center> <!-- date -->
+<center><h4>Oct 6, 2018</h4></center> <!-- date -->
 <br>
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
@@ -910,10 +929,15 @@ pt<span style="color: #666666">.</span>contour(xmesh, ymesh, fmesh, <span style=
 it_array <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array(guesses)
 pt<span style="color: #666666">.</span>plot(it_array<span style="color: #666666">.</span>T[<span style="color: #666666">0</span>], it_array<span style="color: #666666">.</span>T[<span style="color: #666666">1</span>], <span style="color: #BA2121">&quot;x-&quot;</span>)
 </pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec25">Conjugate gradient </h2>
+
 <p>
 <!-- !split  -->
 
-<h2 id="___sec25">Revisiting our first homework </h2>
+<h2 id="___sec26">Revisiting our first homework </h2>
 
 <p>
 We will use linear regression as a case study for the gradient descent
@@ -946,7 +970,7 @@ $$
 <p>
 <!-- !split  -->
 
-<h2 id="___sec26">Gradient descent example </h2>
+<h2 id="___sec27">Gradient descent example </h2>
 
 <p>
 Let \( \mathbf{y} = (y_1,\cdots,y_n)^T \), \( \mathbf{\hat{y}} = (\hat{y}_1,\cdots,\hat{y}_n)^T \) and \( \beta = (\beta_0, \beta_1)^T \)
@@ -971,7 +995,7 @@ and we want to find \( \beta \) such that \( C(\beta) \) is minimized.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec27">The derivative of the cost/loss function </h2>
+<h2 id="___sec28">The derivative of the cost/loss function </h2>
 
 <p>
 Computing \( \partial C(\beta) / \partial \beta_0 \) and \( \partial C(\beta) / \partial \beta_1 \) we can show  that the gradient can be written as
@@ -986,7 +1010,7 @@ where \( X \) is the design matrix defined above.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec28">The Hessian matrix </h2>
+<h2 id="___sec29">The Hessian matrix </h2>
 The Hessian matrix of \( C(\beta) \) is given by 
 $$
 \hat{H} \equiv \begin{bmatrix}
@@ -1000,7 +1024,7 @@ This result implies that \( C(\beta) \) is a convex function since the matrix \(
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec29">Simple program </h2>
+<h2 id="___sec30">Simple program </h2>
 
 <p>
 We can now write a program that minimizes \( C(\beta) \) using the gradient descent method with a constant learning rate \( \gamma \) according to 
@@ -1041,7 +1065,7 @@ beta_NE <span style="color: #666666">=</span> np<span style="color: #666666">.</
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec30">Gradient Descent Example </h2>
+<h2 id="___sec31">Gradient Descent Example </h2>
 
 <p>
 Another simple example is here
@@ -1090,7 +1114,7 @@ plt<span style="color: #666666">.</span>show()
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec31">And a corresponding example using <b>scikit-learn</b> </h2>
+<h2 id="___sec32">And a corresponding example using <b>scikit-learn</b> </h2>
 
 <p>
 
@@ -1114,7 +1138,7 @@ sgdreg<span style="color: #666666">.</span>fit(x,y<span style="color: #666666">.
 <p>
 <!-- !split  -->
 
-<h2 id="___sec32">Gradient descent and Ridge </h2>
+<h2 id="___sec33">Gradient descent and Ridge </h2>
 
 <p>
 We have also discussed Ridge regression where the loss function contains a regularized given by the \( L_2 \) norm of \( \beta \), 
@@ -1171,7 +1195,7 @@ beta_ridge <span style="color: #666666">=</span> np<span style="color: #666666">
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec33">Automatic differentiation </h2>
+<h2 id="___sec34">Automatic differentiation </h2>
 Python has tools for so-called <b>automatic differentiation</b>.
 Consider the following example
 $$
@@ -1226,7 +1250,7 @@ plt<span style="color: #666666">.</span>show()
 <p>
 <!-- !split  -->
 
-<h2 id="___sec34">Using autograd </h2>
+<h2 id="___sec35">Using autograd </h2>
 
 <p>
 Here we
@@ -1259,7 +1283,7 @@ grad_analytical <span style="color: #666666">=</span> <span style="color: #66666
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec35">Autograd with more complicated functions </h2>
+<h2 id="___sec36">Autograd with more complicated functions </h2>
 
 <p>
 To differentiate with respect to two (or more) arguments of a Python
@@ -1309,7 +1333,7 @@ Note that the grad function will not produce the true gradient of the function.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec36">More complicated functions using the elements of their arguments directly </h2>
+<h2 id="___sec37">More complicated functions using the elements of their arguments directly </h2>
 
 <p>
 
@@ -1343,7 +1367,7 @@ could expect form a gradient-evaluting function.
 <p>
 <!-- !split  -->
 
-<h2 id="___sec37">Functions using mathematical functions from Numpy </h2>
+<h2 id="___sec38">Functions using mathematical functions from Numpy </h2>
 
 <p>
 
@@ -1369,7 +1393,7 @@ f4_grad_analytical <span style="color: #666666">=</span> x<span style="color: #6
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec38">More autograd </h2>
+<h2 id="___sec39">More autograd </h2>
 
 <p>
 
@@ -1392,7 +1416,7 @@ x <span style="color: #666666">=</span> <span style="color: #666666">2.7</span>
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec39">And  with loops </h2>
+<h2 id="___sec40">And  with loops </h2>
 
 <p>
 
@@ -1438,7 +1462,7 @@ f6_grad_analytical <span style="color: #666666">=</span> <span style="color: #66
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec40">Using recursion </h2>
+<h2 id="___sec41">Using recursion </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
@@ -1476,7 +1500,7 @@ Note that if n is equal to zero or one, Autograd will give an error message. Thi
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec41">Unsupported functions </h2>
+<h2 id="___sec42">Unsupported functions </h2>
 Autograd supports many features. However, there are some functions that is not supported (yet) by Autograd.
 
 <p>
@@ -1502,7 +1526,7 @@ Here, Autograd tells us that an 'ArrayBox' does not support item assignment. The
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec42">The syntax a.dot(b) when finding the dot product </h2>
+<h2 id="___sec43">The syntax a.dot(b) when finding the dot product </h2>
 <p>
 
 <!-- code=python (!bc pycod) typeset with pygments style "default" -->
@@ -1544,7 +1568,7 @@ x <span style="color: #666666">=</span> np<span style="color: #666666">.</span>a
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec43">Recommended to avoid </h2>
+<h2 id="___sec44">Recommended to avoid </h2>
 The documentation recommends to avoid inplace operations such as
 <p>
 
@@ -1557,7 +1581,7 @@ a <span style="color: #666666">/=</span>b
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec44">Stochastic Gradient Descent </h2>
+<h2 id="___sec45">Stochastic Gradient Descent </h2>
 
 <p>
 Stochastic gradient descent (SGD) and variants thereof address some of
@@ -1575,7 +1599,7 @@ $$
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec45">Computation of gradients </h2>
+<h2 id="___sec46">Computation of gradients </h2>
 
 <p>
 This in turn means that the gradient can be
@@ -1595,7 +1619,7 @@ minibatches. We denote these minibatches by \( B_k \) where
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec46">SGD example </h2>
+<h2 id="___sec47">SGD example </h2>
 As an example, suppose we have \( 10 \) data points \( (\mathbf{x}_1,\cdots, \mathbf{x}_{10}) \) 
 and we choose to have \( M=5 \) minibathces,
 then each minibatch contains two data points. In particular we have
@@ -1619,7 +1643,7 @@ $$
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec47">The gradient step </h2>
+<h2 id="___sec48">The gradient step </h2>
 
 <p>
 Thus a gradient descent step now looks like 
@@ -1638,7 +1662,7 @@ the number of minibatches, as exemplified in the code below.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec48">Simple example code </h2>
+<h2 id="___sec49">Simple example code </h2>
 
 <p>
 
@@ -1670,7 +1694,7 @@ all \( n \) datapoints.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec49">When do we stop? </h2>
+<h2 id="___sec50">When do we stop? </h2>
 
 <p>
 A natural question is when do we stop the search for a new minimum?
@@ -1687,7 +1711,7 @@ gave the lowest value.
 <p>
 <!-- !split --><br><br><br><br><br><br><br><br><br><br>
 
-<h2 id="___sec50">Slightly different approach </h2>
+<h2 id="___sec51">Slightly different approach </h2>
 
 <p>
 Another approach is to let the step length \( \gamma_j \) depend on the
@@ -1732,6 +1756,404 @@ j <span style="color: #666666">=</span> <span style="color: #666666">0</span>
 
 <span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;gamma_j after </span><span style="color: #BB6688; font-weight: bold">%d</span><span style="color: #BA2121"> epochs: </span><span style="color: #BB6688; font-weight: bold">%g</span><span style="color: #BA2121">&quot;</span> <span style="color: #666666">%</span> (n_epochs,gamma_j))
 </pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec52">Program for stochastic gradient </h2>
+
+<p>
+
+<!-- code=python (!bc pycod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span><span style="color: #408080; font-style: italic"># Importing various packages</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">math</span> <span style="color: #008000; font-weight: bold">import</span> exp, sqrt
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">random</span> <span style="color: #008000; font-weight: bold">import</span> random, seed
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">numpy</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">np</span>
+<span style="color: #008000; font-weight: bold">import</span> <span style="color: #0000FF; font-weight: bold">matplotlib.pyplot</span> <span style="color: #008000; font-weight: bold">as</span> <span style="color: #0000FF; font-weight: bold">plt</span>
+<span style="color: #008000; font-weight: bold">from</span> <span style="color: #0000FF; font-weight: bold">sklearn.linear_model</span> <span style="color: #008000; font-weight: bold">import</span> SGDRegressor
+
+x <span style="color: #666666">=</span> <span style="color: #666666">2*</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>rand(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
+y <span style="color: #666666">=</span> <span style="color: #666666">4+3*</span>x<span style="color: #666666">+</span>np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)
+
+xb <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">100</span>,<span style="color: #666666">1</span>)), x]
+theta_linreg <span style="color: #666666">=</span> np<span style="color: #666666">.</span>linalg<span style="color: #666666">.</span>inv(xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb))<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>T)<span style="color: #666666">.</span>dot(y)
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;Own inversion&quot;</span>)
+<span style="color: #008000; font-weight: bold">print</span>(theta_linreg)
+sgdreg <span style="color: #666666">=</span> SGDRegressor(n_iter <span style="color: #666666">=</span> <span style="color: #666666">50</span>, penalty<span style="color: #666666">=</span><span style="color: #008000">None</span>, eta0<span style="color: #666666">=0.1</span>)
+sgdreg<span style="color: #666666">.</span>fit(x,y<span style="color: #666666">.</span>ravel())
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;sgdreg from scikit&quot;</span>)
+<span style="color: #008000; font-weight: bold">print</span>(sgdreg<span style="color: #666666">.</span>intercept_, sgdreg<span style="color: #666666">.</span>coef_)
+
+
+theta <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)
+
+eta <span style="color: #666666">=</span> <span style="color: #666666">0.1</span>
+Niterations <span style="color: #666666">=</span> <span style="color: #666666">1000</span>
+m <span style="color: #666666">=</span> <span style="color: #666666">100</span>
+
+<span style="color: #008000; font-weight: bold">for</span> <span style="color: #008000">iter</span> <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(Niterations):
+    gradients <span style="color: #666666">=</span> <span style="color: #666666">2.0/</span>m<span style="color: #666666">*</span>xb<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xb<span style="color: #666666">.</span>dot(theta)<span style="color: #666666">-</span>y)
+    theta <span style="color: #666666">-=</span> eta<span style="color: #666666">*</span>gradients
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;theta frm own gd&quot;</span>)
+<span style="color: #008000; font-weight: bold">print</span>(theta)
+
+xnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>array([[<span style="color: #666666">0</span>],[<span style="color: #666666">2</span>]])
+xbnew <span style="color: #666666">=</span> np<span style="color: #666666">.</span>c_[np<span style="color: #666666">.</span>ones((<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)), xnew]
+ypredict <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(theta)
+ypredict2 <span style="color: #666666">=</span> xbnew<span style="color: #666666">.</span>dot(theta_linreg)
+
+
+n_epochs <span style="color: #666666">=</span> <span style="color: #666666">50</span>
+t0, t1 <span style="color: #666666">=</span> <span style="color: #666666">5</span>, <span style="color: #666666">50</span>
+m <span style="color: #666666">=</span> <span style="color: #666666">100</span>
+<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0000FF">learning_schedule</span>(t):
+    <span style="color: #008000; font-weight: bold">return</span> t0<span style="color: #666666">/</span>(t<span style="color: #666666">+</span>t1)
+
+theta <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randn(<span style="color: #666666">2</span>,<span style="color: #666666">1</span>)
+
+<span style="color: #008000; font-weight: bold">for</span> epoch <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(n_epochs):
+    <span style="color: #008000; font-weight: bold">for</span> i <span style="color: #AA22FF; font-weight: bold">in</span> <span style="color: #008000">range</span>(m):
+        random_index <span style="color: #666666">=</span> np<span style="color: #666666">.</span>random<span style="color: #666666">.</span>randint(m)
+        xi <span style="color: #666666">=</span> xb[random_index:random_index<span style="color: #666666">+1</span>]
+        yi <span style="color: #666666">=</span> y[random_index:random_index<span style="color: #666666">+1</span>]
+        gradients <span style="color: #666666">=</span> <span style="color: #666666">2</span> <span style="color: #666666">*</span> xi<span style="color: #666666">.</span>T<span style="color: #666666">.</span>dot(xi<span style="color: #666666">.</span>dot(theta)<span style="color: #666666">-</span>yi)
+        eta <span style="color: #666666">=</span> learning_schedule(epoch<span style="color: #666666">*</span>m<span style="color: #666666">+</span>i)
+        theta <span style="color: #666666">=</span> theta <span style="color: #666666">-</span> eta<span style="color: #666666">*</span>gradients
+<span style="color: #008000; font-weight: bold">print</span>(<span style="color: #BA2121">&quot;theta from own sdg&quot;</span>)
+<span style="color: #008000; font-weight: bold">print</span>(theta)
+
+
+
+
+
+
+plt<span style="color: #666666">.</span>plot(xnew, ypredict, <span style="color: #BA2121">&quot;r-&quot;</span>)
+plt<span style="color: #666666">.</span>plot(xnew, ypredict2, <span style="color: #BA2121">&quot;b-&quot;</span>)
+plt<span style="color: #666666">.</span>plot(x, y ,<span style="color: #BA2121">&#39;ro&#39;</span>)
+plt<span style="color: #666666">.</span>axis([<span style="color: #666666">0</span>,<span style="color: #666666">2.0</span>,<span style="color: #666666">0</span>, <span style="color: #666666">15.0</span>])
+plt<span style="color: #666666">.</span>xlabel(<span style="color: #BA2121">r&#39;$x$&#39;</span>)
+plt<span style="color: #666666">.</span>ylabel(<span style="color: #BA2121">r&#39;$y$&#39;</span>)
+plt<span style="color: #666666">.</span>title(<span style="color: #BA2121">r&#39;Random numbers &#39;</span>)
+plt<span style="color: #666666">.</span>show()
+</pre></div>
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec53">Momentum based methods </h2>
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec54">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+In the CG method we define so-called conjugate directions and two vectors 
+\( \hat{s} \) and \( \hat{t} \)
+are said to be
+conjugate if
+$$
+\begin{equation*}
+\hat{s}^T\hat{A}\hat{t}= 0.
+\end{equation*}
+$$
+
+The philosophy of the CG method is to perform searches in various conjugate directions
+of our vectors \( \hat{x}_i \) obeying the above criterion, namely
+$$
+\begin{equation*}
+\hat{x}_i^T\hat{A}\hat{x}_j= 0.
+\end{equation*}
+$$
+
+Two vectors are conjugate if they are orthogonal with respect to 
+this inner product. Being conjugate is a symmetric relation: if \( \hat{s} \) is conjugate to \( \hat{t} \), then \( \hat{t} \) is conjugate to \( \hat{s} \).
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec55">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+An example is given by the eigenvectors of the matrix
+$$
+\begin{equation*}
+\hat{v}_i^T\hat{A}\hat{v}_j= \lambda\hat{v}_i^T\hat{v}_j,
+\end{equation*}
+$$
+
+which is zero unless \( i=j \).
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec56">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Assume now that we have a symmetric positive-definite matrix \( \hat{A} \) of size
+\( n\times n \). At each iteration \( i+1 \) we obtain the conjugate direction of a vector
+$$
+\begin{equation*}
+\hat{x}_{i+1}=\hat{x}_{i}+\alpha_i\hat{p}_{i}. 
+\end{equation*}
+$$
+
+We assume that \( \hat{p}_{i} \) is a sequence of \( n \) mutually conjugate directions. 
+Then the \( \hat{p}_{i} \)  form a basis of \( R^n \) and we can expand the solution 
+$  \hat{A}\hat{x} = \hat{b}$ in this basis, namely
+
+$$
+\begin{equation*}
+  \hat{x}  = \sum^{n}_{i=1} \alpha_i \hat{p}_i.
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec57">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The coefficients are given by
+$$
+\begin{equation*}
+    \mathbf{A}\mathbf{x} = \sum^{n}_{i=1} \alpha_i \mathbf{A} \mathbf{p}_i = \mathbf{b}.
+\end{equation*}
+$$
+
+Multiplying with \( \hat{p}_k^T \)  from the left gives
+
+$$
+\begin{equation*}
+  \hat{p}_k^T \hat{A}\hat{x} = \sum^{n}_{i=1} \alpha_i\hat{p}_k^T \hat{A}\hat{p}_i= \hat{p}_k^T \hat{b},
+\end{equation*}
+$$
+
+and we can define the coefficients \( \alpha_k \) as
+
+$$
+\begin{equation*}
+    \alpha_k = \frac{\hat{p}_k^T \hat{b}}{\hat{p}_k^T \hat{A} \hat{p}_k}
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec58">Conjugate gradient method and iterations </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+
+<p>
+If we choose the conjugate vectors \( \hat{p}_k \) carefully, 
+then we may not need all of them to obtain a good approximation to the solution 
+\( \hat{x} \). 
+We want to regard the conjugate gradient method as an iterative method. 
+This will us to solve systems where \( n \) is so large that the direct 
+method would take too much time.
+
+<p>
+We denote the initial guess for \( \hat{x} \) as \( \hat{x}_0 \). 
+We can assume without loss of generality that
+$$
+\begin{equation*}
+\hat{x}_0=0,
+\end{equation*}
+$$
+
+or consider the system
+$$
+\begin{equation*}
+\hat{A}\hat{z} = \hat{b}-\hat{A}\hat{x}_0,
+\end{equation*}
+$$
+
+instead.
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec59">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+One can show that the solution \( \hat{x} \) is also the unique minimizer of the quadratic form
+$$
+\begin{equation*}
+  f(\hat{x}) = \frac{1}{2}\hat{x}^T\hat{A}\hat{x} - \hat{x}^T \hat{x} , \quad \hat{x}\in\mathbf{R}^n. 
+\end{equation*}
+$$
+
+This suggests taking the first basis vector \( \hat{p}_1 \) 
+to be the gradient of \( f \) at \( \hat{x}=\hat{x}_0 \), 
+which equals
+$$
+\begin{equation*}
+\hat{A}\hat{x}_0-\hat{b},
+\end{equation*}
+$$
+
+and 
+\( \hat{x}_0=0 \) it is equal \( -\hat{b} \).
+The other vectors in the basis will be conjugate to the gradient, 
+hence the name conjugate gradient method.
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec60">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+Let  \( \hat{r}_k \) be the residual at the \( k \)-th step:
+$$
+\begin{equation*}
+\hat{r}_k=\hat{b}-\hat{A}\hat{x}_k.
+\end{equation*}
+$$
+
+Note that \( \hat{r}_k \) is the negative gradient of \( f \) at 
+\( \hat{x}=\hat{x}_k \), 
+so the gradient descent method would be to move in the direction \( \hat{r}_k \). 
+Here, we insist that the directions \( \hat{p}_k \) are conjugate to each other, 
+so we take the direction closest to the gradient \( \hat{r}_k \)  
+under the conjugacy constraint. 
+This gives the following expression
+$$
+\begin{equation*}
+\hat{p}_{k+1}=\hat{r}_k-\frac{\hat{p}_k^T \hat{A}\hat{r}_k}{\hat{p}_k^T\hat{A}\hat{p}_k} \hat{p}_k.
+\end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec61">Conjugate gradient method </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+We can also  compute the residual iteratively as
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{b}-\hat{A}\hat{x}_{k+1},
+ \end{equation*}
+$$
+
+which equals
+$$
+\begin{equation*}
+\hat{b}-\hat{A}(\hat{x}_k+\alpha_k\hat{p}_k),
+ \end{equation*}
+$$
+
+or
+$$
+\begin{equation*}
+(\hat{b}-\hat{A}\hat{x}_k)-\alpha_k\hat{A}\hat{p}_k,
+ \end{equation*}
+$$
+
+which gives
+
+$$
+\begin{equation*}
+\hat{r}_{k+1}=\hat{r}_k-\hat{A}\hat{p}_{k},
+ \end{equation*}
+$$
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec62">Simple implementation of the Conjugate gradient algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+<p>
+
+<!-- code=c++ (!bc cppcod) typeset with pygments style "default" -->
+<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><span></span>  Vector <span style="color: #0000FF">ConjugateGradient</span>(Matrix A, Vector b, Vector x0){
+  <span style="color: #B00040">int</span> dim <span style="color: #666666">=</span> x0.Dimension();
+  <span style="color: #008000; font-weight: bold">const</span> <span style="color: #B00040">double</span> tolerance <span style="color: #666666">=</span> <span style="color: #666666">1.0e-14</span>;
+  Vector x(dim),r(dim),v(dim),z(dim);
+  <span style="color: #B00040">double</span> c,t,d;
+
+  x <span style="color: #666666">=</span> x0;
+  r <span style="color: #666666">=</span> b <span style="color: #666666">-</span> A<span style="color: #666666">*</span>x;
+  v <span style="color: #666666">=</span> r;
+  c <span style="color: #666666">=</span> dot(r,r);
+  <span style="color: #B00040">int</span> i <span style="color: #666666">=</span> <span style="color: #666666">0</span>; IterMax <span style="color: #666666">=</span> dim;
+  <span style="color: #008000; font-weight: bold">while</span>(i <span style="color: #666666">&lt;=</span> IterMax){
+    z <span style="color: #666666">=</span> A<span style="color: #666666">*</span>v;
+    t <span style="color: #666666">=</span> c<span style="color: #666666">/</span>dot(v,z);
+    x <span style="color: #666666">=</span> x <span style="color: #666666">+</span> t<span style="color: #666666">*</span>v;
+    r <span style="color: #666666">=</span> r <span style="color: #666666">-</span> t<span style="color: #666666">*</span>z;
+    d <span style="color: #666666">=</span> dot(r,r);
+    <span style="color: #008000; font-weight: bold">if</span>(sqrt(d) <span style="color: #666666">&lt;</span> tolerance)
+      <span style="color: #008000; font-weight: bold">break</span>;
+    v <span style="color: #666666">=</span> r <span style="color: #666666">+</span> (d<span style="color: #666666">/</span>c)<span style="color: #666666">*</span>v;
+    c <span style="color: #666666">=</span> d;  i<span style="color: #666666">++</span>;
+  }
+  <span style="color: #008000; font-weight: bold">return</span> x;
+} 
+</pre></div>
+
+</div>
+
+
+<p>
+<!-- !split --><br><br><br><br><br><br><br><br><br><br>
+
+<h2 id="___sec63">Broyden&#8211;Fletcher&#8211;Goldfarb&#8211;Shanno algorithm </h2>
+<div class="alert alert-block alert-block alert-text-normal">
+<b></b>
+<p>
+The optimization problem is to minimize \( f(\mathbf {x} ) \) where \( \mathbf {x} \)  is a vector in \( R^{n} \), and \( f \) is a differentiable scalar function. There are no constraints on the values that  \( \mathbf {x} \)  can take.
+
+<p>
+The algorithm begins at an initial estimate for the optimal value \( \mathbf {x}_{0} \) and proceeds iteratively to get a better estimate at each stage.
+
+<p>
+The search direction \( p_k \) at stage \( k \) is given by the solution of the analogue of the Newton equation
+$$
+B_{k}\mathbf {p} _{k}=-\nabla f(\mathbf {x}_{k}),
+$$
+
+<p>
+where \( B_{k} \) is an approximation to the Hessian matrix, which is
+updated iteratively at each stage, and \( \nabla f(\mathbf {x} _{k}) \)
+is the gradient of the function
+evaluated at \( x_k \). 
+A line search in the direction \( p_k \) is then used to
+find the next point \( x_{k+1} \) by minimising 
+$$
+f(\mathbf {x}_{k}+\alpha \mathbf {p}_{k}),
+$$
+
+over the scalar \( \alpha > 0 \).
+
+
+</div>
+
+
 <p>
 
 <!-- ------------------- end of main content --------------- -->
diff --git a/doc/pub/Splines/ipynb/Splines.ipynb b/doc/pub/Splines/ipynb/Splines.ipynb
index 350eb63c0..48e3c51fa 100644
--- a/doc/pub/Splines/ipynb/Splines.ipynb
+++ b/doc/pub/Splines/ipynb/Splines.ipynb
@@ -10,7 +10,7 @@
     "<!-- Author: -->  \n",
     "**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University\n",
     "\n",
-    "Date: **Sep 27, 2018**\n",
+    "Date: **Oct 6, 2018**\n",
     "\n",
     "Copyright 1999-2018, Morten Hjorth-Jensen. Released under CC Attribution-NonCommercial 4.0 license\n",
     "\n",
@@ -844,29 +844,10 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x109127ac8>"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "%matplotlib inline\n",
     "\n",
@@ -902,19 +883,10 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "pt.axis(\"equal\")\n",
     "pt.contour(xmesh, ymesh, fmesh)\n",
@@ -931,7 +903,9 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "x = guesses[-1]\n",
@@ -948,16 +922,10 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ 1.33333333 -0.26666667]\n"
-     ]
-    }
-   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "def f1d(alpha):\n",
     "    return f(x + alpha*s)\n",
@@ -978,29 +946,10 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x109c1e438>]"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "pt.axis(\"equal\")\n",
     "pt.contour(xmesh, ymesh, fmesh, 50)\n",
@@ -1012,6 +961,10 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Conjugate gradient\n",
+    "\n",
+    "\n",
+    "\n",
     "<!-- !split  -->\n",
     "## Revisiting our first homework\n",
     "\n",
@@ -1162,6 +1115,9 @@
    "source": [
     "This result implies that $C(\\beta)$ is a convex function since the matrix $X^T X$ always is positive semi-definite.\n",
     "\n",
+    "\n",
+    "\n",
+    "\n",
     "## Simple program\n",
     "\n",
     "We can now write a program that minimizes $C(\\beta)$ using the gradient descent method with a constant learning rate $\\gamma$ according to"
@@ -1191,7 +1147,9 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import numpy as np\n",
@@ -1225,30 +1183,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[3.96812677]\n",
-      " [2.93472871]]\n",
-      "[[3.96812677]\n",
-      " [2.93472871]]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "\n",
     "# Importing various packages\n",
@@ -1301,7 +1240,9 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# Importing various packages\n",
@@ -1385,7 +1326,9 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import numpy as np\n",
@@ -1458,27 +1401,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The max absolute difference is: 1.77636e-15\n"
-     ]
-    }
-   ],
+   "execution_count": 10,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
     "\n",
@@ -1532,18 +1459,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The gradient of f1 evaluated at a = 1 using autograd is: 3\n",
-      "The gradient of f1 evaluated at a = 1 by finding the analytic expression is: 3\n"
-     ]
-    }
-   ],
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
     "from autograd import grad\n",
@@ -1578,7 +1498,9 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1629,7 +1551,9 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1669,7 +1593,9 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1701,7 +1627,9 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1761,7 +1689,9 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1785,7 +1715,9 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1832,7 +1764,9 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1860,7 +1794,9 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1888,7 +1824,9 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import autograd.numpy as np\n",
@@ -1918,7 +1856,9 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "a += b\n",
@@ -2043,7 +1983,9 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import numpy as np \n",
@@ -2105,7 +2047,9 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "import numpy as np \n",
@@ -2133,27 +2077,529 @@
     "\n",
     "print(\"gamma_j after %d epochs: %g\" % (n_epochs,gamma_j))"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Program for stochastic gradient"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# Importing various packages\n",
+    "from math import exp, sqrt\n",
+    "from random import random, seed\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.linear_model import SGDRegressor\n",
+    "\n",
+    "x = 2*np.random.rand(100,1)\n",
+    "y = 4+3*x+np.random.randn(100,1)\n",
+    "\n",
+    "xb = np.c_[np.ones((100,1)), x]\n",
+    "theta_linreg = np.linalg.inv(xb.T.dot(xb)).dot(xb.T).dot(y)\n",
+    "print(\"Own inversion\")\n",
+    "print(theta_linreg)\n",
+    "sgdreg = SGDRegressor(n_iter = 50, penalty=None, eta0=0.1)\n",
+    "sgdreg.fit(x,y.ravel())\n",
+    "print(\"sgdreg from scikit\")\n",
+    "print(sgdreg.intercept_, sgdreg.coef_)\n",
+    "\n",
+    "\n",
+    "theta = np.random.randn(2,1)\n",
+    "\n",
+    "eta = 0.1\n",
+    "Niterations = 1000\n",
+    "m = 100\n",
+    "\n",
+    "for iter in range(Niterations):\n",
+    "    gradients = 2.0/m*xb.T.dot(xb.dot(theta)-y)\n",
+    "    theta -= eta*gradients\n",
+    "print(\"theta frm own gd\")\n",
+    "print(theta)\n",
+    "\n",
+    "xnew = np.array([[0],[2]])\n",
+    "xbnew = np.c_[np.ones((2,1)), xnew]\n",
+    "ypredict = xbnew.dot(theta)\n",
+    "ypredict2 = xbnew.dot(theta_linreg)\n",
+    "\n",
+    "\n",
+    "n_epochs = 50\n",
+    "t0, t1 = 5, 50\n",
+    "m = 100\n",
+    "def learning_schedule(t):\n",
+    "    return t0/(t+t1)\n",
+    "\n",
+    "theta = np.random.randn(2,1)\n",
+    "\n",
+    "for epoch in range(n_epochs):\n",
+    "    for i in range(m):\n",
+    "        random_index = np.random.randint(m)\n",
+    "        xi = xb[random_index:random_index+1]\n",
+    "        yi = y[random_index:random_index+1]\n",
+    "        gradients = 2 * xi.T.dot(xi.dot(theta)-yi)\n",
+    "        eta = learning_schedule(epoch*m+i)\n",
+    "        theta = theta - eta*gradients\n",
+    "print(\"theta from own sdg\")\n",
+    "print(theta)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "plt.plot(xnew, ypredict, \"r-\")\n",
+    "plt.plot(xnew, ypredict2, \"b-\")\n",
+    "plt.plot(x, y ,'ro')\n",
+    "plt.axis([0,2.0,0, 15.0])\n",
+    "plt.xlabel(r'$x$')\n",
+    "plt.ylabel(r'$y$')\n",
+    "plt.title(r'Random numbers ')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Momentum based methods\n",
+    "\n",
+    "\n",
+    "\n",
+    "## Conjugate gradient method\n",
+    "In the CG method we define so-called conjugate directions and two vectors \n",
+    "$\\hat{s}$ and $\\hat{t}$\n",
+    "are said to be\n",
+    "conjugate if"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{s}^T\\hat{A}\\hat{t}= 0.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The philosophy of the CG method is to perform searches in various conjugate directions\n",
+    "of our vectors $\\hat{x}_i$ obeying the above criterion, namely"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{x}_i^T\\hat{A}\\hat{x}_j= 0.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Two vectors are conjugate if they are orthogonal with respect to \n",
+    "this inner product. Being conjugate is a symmetric relation: if $\\hat{s}$ is conjugate to $\\hat{t}$, then $\\hat{t}$ is conjugate to $\\hat{s}$.\n",
+    "\n",
+    "\n",
+    "\n",
+    "## Conjugate gradient method\n",
+    "An example is given by the eigenvectors of the matrix"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{v}_i^T\\hat{A}\\hat{v}_j= \\lambda\\hat{v}_i^T\\hat{v}_j,\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "which is zero unless $i=j$.\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "## Conjugate gradient method\n",
+    "Assume now that we have a symmetric positive-definite matrix $\\hat{A}$ of size\n",
+    "$n\\times n$. At each iteration $i+1$ we obtain the conjugate direction of a vector"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{x}_{i+1}=\\hat{x}_{i}+\\alpha_i\\hat{p}_{i}.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We assume that $\\hat{p}_{i}$ is a sequence of $n$ mutually conjugate directions. \n",
+    "Then the $\\hat{p}_{i}$  form a basis of $R^n$ and we can expand the solution \n",
+    "$  \\hat{A}\\hat{x} = \\hat{b}$ in this basis, namely"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{x}  = \\sum^{n}_{i=1} \\alpha_i \\hat{p}_i.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conjugate gradient method\n",
+    "The coefficients are given by"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\mathbf{A}\\mathbf{x} = \\sum^{n}_{i=1} \\alpha_i \\mathbf{A} \\mathbf{p}_i = \\mathbf{b}.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Multiplying with $\\hat{p}_k^T$  from the left gives"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{p}_k^T \\hat{A}\\hat{x} = \\sum^{n}_{i=1} \\alpha_i\\hat{p}_k^T \\hat{A}\\hat{p}_i= \\hat{p}_k^T \\hat{b},\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "and we can define the coefficients $\\alpha_k$ as"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\alpha_k = \\frac{\\hat{p}_k^T \\hat{b}}{\\hat{p}_k^T \\hat{A} \\hat{p}_k}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conjugate gradient method and iterations\n",
+    "\n",
+    "If we choose the conjugate vectors $\\hat{p}_k$ carefully, \n",
+    "then we may not need all of them to obtain a good approximation to the solution \n",
+    "$\\hat{x}$. \n",
+    "We want to regard the conjugate gradient method as an iterative method. \n",
+    "This will us to solve systems where $n$ is so large that the direct \n",
+    "method would take too much time.\n",
+    "\n",
+    "We denote the initial guess for $\\hat{x}$ as $\\hat{x}_0$. \n",
+    "We can assume without loss of generality that"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{x}_0=0,\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "or consider the system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{A}\\hat{z} = \\hat{b}-\\hat{A}\\hat{x}_0,\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "instead.\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "## Conjugate gradient method\n",
+    "One can show that the solution $\\hat{x}$ is also the unique minimizer of the quadratic form"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "f(\\hat{x}) = \\frac{1}{2}\\hat{x}^T\\hat{A}\\hat{x} - \\hat{x}^T \\hat{x} , \\quad \\hat{x}\\in\\mathbf{R}^n.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This suggests taking the first basis vector $\\hat{p}_1$ \n",
+    "to be the gradient of $f$ at $\\hat{x}=\\hat{x}_0$, \n",
+    "which equals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{A}\\hat{x}_0-\\hat{b},\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "and \n",
+    "$\\hat{x}_0=0$ it is equal $-\\hat{b}$.\n",
+    "The other vectors in the basis will be conjugate to the gradient, \n",
+    "hence the name conjugate gradient method.\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "## Conjugate gradient method\n",
+    "Let  $\\hat{r}_k$ be the residual at the $k$-th step:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{r}_k=\\hat{b}-\\hat{A}\\hat{x}_k.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that $\\hat{r}_k$ is the negative gradient of $f$ at \n",
+    "$\\hat{x}=\\hat{x}_k$, \n",
+    "so the gradient descent method would be to move in the direction $\\hat{r}_k$. \n",
+    "Here, we insist that the directions $\\hat{p}_k$ are conjugate to each other, \n",
+    "so we take the direction closest to the gradient $\\hat{r}_k$  \n",
+    "under the conjugacy constraint. \n",
+    "This gives the following expression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{p}_{k+1}=\\hat{r}_k-\\frac{\\hat{p}_k^T \\hat{A}\\hat{r}_k}{\\hat{p}_k^T\\hat{A}\\hat{p}_k} \\hat{p}_k.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conjugate gradient method\n",
+    "We can also  compute the residual iteratively as"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{r}_{k+1}=\\hat{b}-\\hat{A}\\hat{x}_{k+1},\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "which equals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{b}-\\hat{A}(\\hat{x}_k+\\alpha_k\\hat{p}_k),\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "or"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "(\\hat{b}-\\hat{A}\\hat{x}_k)-\\alpha_k\\hat{A}\\hat{p}_k,\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "which gives"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\hat{r}_{k+1}=\\hat{r}_k-\\hat{A}\\hat{p}_{k},\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simple implementation of the Conjugate gradient algorithm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "          Vector ConjugateGradient(Matrix A, Vector b, Vector x0){\n",
+    "          int dim = x0.Dimension();\n",
+    "          const double tolerance = 1.0e-14;\n",
+    "          Vector x(dim),r(dim),v(dim),z(dim);\n",
+    "          double c,t,d;\n",
+    "        \n",
+    "          x = x0;\n",
+    "          r = b - A*x;\n",
+    "          v = r;\n",
+    "          c = dot(r,r);\n",
+    "          int i = 0; IterMax = dim;\n",
+    "          while(i <= IterMax){\n",
+    "            z = A*v;\n",
+    "            t = c/dot(v,z);\n",
+    "            x = x + t*v;\n",
+    "            r = r - t*z;\n",
+    "            d = dot(r,r);\n",
+    "            if(sqrt(d) < tolerance)\n",
+    "              break;\n",
+    "            v = r + (d/c)*v;\n",
+    "            c = d;  i++;\n",
+    "          }\n",
+    "          return x;\n",
+    "        } \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Broyden–Fletcher–Goldfarb–Shanno algorithm\n",
+    "The optimization problem is to minimize $f(\\mathbf {x} )$ where $\\mathbf {x}$  is a vector in $R^{n}$, and $f$ is a differentiable scalar function. There are no constraints on the values that  $\\mathbf {x}$  can take.\n",
+    "\n",
+    "The algorithm begins at an initial estimate for the optimal value $\\mathbf {x}_{0}$ and proceeds iteratively to get a better estimate at each stage.\n",
+    "\n",
+    "The search direction $p_k$ at stage $k$ is given by the solution of the analogue of the Newton equation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "B_{k}\\mathbf {p} _{k}=-\\nabla f(\\mathbf {x}_{k}),\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "where $B_{k}$ is an approximation to the Hessian matrix, which is\n",
+    "updated iteratively at each stage, and $\\nabla f(\\mathbf {x} _{k})$\n",
+    "is the gradient of the function\n",
+    "evaluated at $x_k$. \n",
+    "A line search in the direction $p_k$ is then used to\n",
+    "find the next point $x_{k+1}$ by minimising"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "f(\\mathbf {x}_{k}+\\alpha \\mathbf {p}_{k}),\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "over the scalar $\\alpha > 0$."
+   ]
   }
  ],
- "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.0"
-  }
- },
+ "metadata": {},
  "nbformat": 4,
  "nbformat_minor": 2
 }
diff --git a/doc/pub/Splines/ipynb/ipynb-Splines-src.tar.gz b/doc/pub/Splines/ipynb/ipynb-Splines-src.tar.gz
index ad687d95f12dd08b8ff209e5ec183c29e529b110..7b7bb3026191d00a5cfb5e773ca79c930459c5d9 100644
GIT binary patch
literal 209
zcmb2|=3v++yfd1C`R#e%E+#{Pw#4i67WrLR^0)JKW1(R;W1zmkOAFchNoJi1_v@ls
z3zu38&isC}MspQM=;xQmpMT$SV)>nFsijlodY{Y@w%xZxD&}?frYk{w?a8(;;-b1=
zajmUdG;jN*vxcd{yF*{~em(hXck$gDRevAMf35jxdVW&mZk71WX4emP^WR+ObmP>b
zo0j>(4`*Flzl6(dZne<chc6b1K8`jFeY%PJ-kV>(JoXpg1YfNGYRZ5NKGgqV%D-{{
J1A_(w0|5D+XD$E$

literal 211
zcmb2|=3qFocuh0|^V{?1vzQD8ju)Q)E%KSg`_aFTF&CQKn{MoLNJ%zdt9Dz(>HFK=
zT3eQXQ(OAuZ%iGJF^}=>tA{@ohCb`J*)6#=B>H;MIoI1UL1)*0ZN0Yk#i}eV+w0t+
z-LtxO&F$QE*Ym!g=4^|(m-a`^U-Q2(PwMvj`kTeIuKPaCuXq<b>1*1V+7FMMx9t|V
z_axK8B0u<L+r{@wxXtEP3%&h)(pCFdf6}gVsp5MqMVxu`FUkZ*{`qRofD8)k?HC`u
Lc*4t|!N33j{_<yg

diff --git a/doc/pub/Splines/pdf/Splines-minted.pdf b/doc/pub/Splines/pdf/Splines-minted.pdf
index 52cef4c59b35f9128c158707f88b0baec0ba409c..4e31571bda3fd14878e2be526be06132d370c4bd 100644
GIT binary patch
delta 91458
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
Vogjb|?Opuj<wc>Tl~$EO`7f5ot_%PG

delta 80940
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
YpXP4{Ab@A);$&xrrJ(q!AP)P#0GInJU;qFB

diff --git a/doc/src/Splines/Splines.do.txt b/doc/src/Splines/Splines.do.txt
index ef15d68f9..a71620b87 100644
--- a/doc/src/Splines/Splines.do.txt
+++ b/doc/src/Splines/Splines.do.txt
@@ -1459,3 +1459,255 @@ plt.show()
 ===== Momentum based methods =====
 
 
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+In the CG method we define so-called conjugate directions and two vectors 
+$\hat{s}$ and $\hat{t}$
+are said to be
+conjugate if
+!bt
+\begin{equation*}
+\hat{s}^T\hat{A}\hat{t}= 0.
+\end{equation*}
+!et
+The philosophy of the CG method is to perform searches in various conjugate directions
+of our vectors $\hat{x}_i$ obeying the above criterion, namely
+!bt
+\begin{equation*}
+\hat{x}_i^T\hat{A}\hat{x}_j= 0.
+\end{equation*}
+!et
+Two vectors are conjugate if they are orthogonal with respect to 
+this inner product. Being conjugate is a symmetric relation: if $\hat{s}$ is conjugate to $\hat{t}$, then $\hat{t}$ is conjugate to $\hat{s}$.
+!eblock
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+An example is given by the eigenvectors of the matrix
+!bt
+\begin{equation*}
+\hat{v}_i^T\hat{A}\hat{v}_j= \lambda\hat{v}_i^T\hat{v}_j,
+\end{equation*}
+!et
+which is zero unless $i=j$. 
+!eblock
+
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+Assume now that we have a symmetric positive-definite matrix $\hat{A}$ of size
+$n\times n$. At each iteration $i+1$ we obtain the conjugate direction of a vector
+!bt
+\begin{equation*}
+\hat{x}_{i+1}=\hat{x}_{i}+\alpha_i\hat{p}_{i}. 
+\end{equation*}
+!et
+We assume that $\hat{p}_{i}$ is a sequence of $n$ mutually conjugate directions. 
+Then the $\hat{p}_{i}$  form a basis of $R^n$ and we can expand the solution 
+$  \hat{A}\hat{x} = \hat{b}$ in this basis, namely
+
+!bt
+\begin{equation*}
+  \hat{x}  = \sum^{n}_{i=1} \alpha_i \hat{p}_i.
+\end{equation*}
+!et
+!eblock
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+The coefficients are given by
+!bt
+\begin{equation*}
+    \mathbf{A}\mathbf{x} = \sum^{n}_{i=1} \alpha_i \mathbf{A} \mathbf{p}_i = \mathbf{b}.
+\end{equation*}
+!et
+Multiplying with $\hat{p}_k^T$  from the left gives
+
+!bt
+\begin{equation*}
+  \hat{p}_k^T \hat{A}\hat{x} = \sum^{n}_{i=1} \alpha_i\hat{p}_k^T \hat{A}\hat{p}_i= \hat{p}_k^T \hat{b},
+\end{equation*}
+!et
+and we can define the coefficients $\alpha_k$ as
+
+!bt
+\begin{equation*}
+    \alpha_k = \frac{\hat{p}_k^T \hat{b}}{\hat{p}_k^T \hat{A} \hat{p}_k}
+\end{equation*}
+!et 
+!eblock
+
+!split
+===== Conjugate gradient method and iterations ===== 
+!bblock
+
+If we choose the conjugate vectors $\hat{p}_k$ carefully, 
+then we may not need all of them to obtain a good approximation to the solution 
+$\hat{x}$. 
+We want to regard the conjugate gradient method as an iterative method. 
+This will us to solve systems where $n$ is so large that the direct 
+method would take too much time.
+
+We denote the initial guess for $\hat{x}$ as $\hat{x}_0$. 
+We can assume without loss of generality that
+!bt
+\begin{equation*}
+\hat{x}_0=0,
+\end{equation*}
+!et
+or consider the system
+!bt
+\begin{equation*}
+\hat{A}\hat{z} = \hat{b}-\hat{A}\hat{x}_0,
+\end{equation*}
+!et
+instead.
+!eblock
+
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+One can show that the solution $\hat{x}$ is also the unique minimizer of the quadratic form
+!bt
+\begin{equation*}
+  f(\hat{x}) = \frac{1}{2}\hat{x}^T\hat{A}\hat{x} - \hat{x}^T \hat{x} , \quad \hat{x}\in\mathbf{R}^n. 
+\end{equation*}
+!et
+This suggests taking the first basis vector $\hat{p}_1$ 
+to be the gradient of $f$ at $\hat{x}=\hat{x}_0$, 
+which equals
+!bt
+\begin{equation*}
+\hat{A}\hat{x}_0-\hat{b},
+\end{equation*}
+!et
+and 
+$\hat{x}_0=0$ it is equal $-\hat{b}$.
+The other vectors in the basis will be conjugate to the gradient, 
+hence the name conjugate gradient method.
+!eblock
+
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+Let  $\hat{r}_k$ be the residual at the $k$-th step:
+!bt
+\begin{equation*}
+\hat{r}_k=\hat{b}-\hat{A}\hat{x}_k.
+\end{equation*}
+!et
+Note that $\hat{r}_k$ is the negative gradient of $f$ at 
+$\hat{x}=\hat{x}_k$, 
+so the gradient descent method would be to move in the direction $\hat{r}_k$. 
+Here, we insist that the directions $\hat{p}_k$ are conjugate to each other, 
+so we take the direction closest to the gradient $\hat{r}_k$  
+under the conjugacy constraint. 
+This gives the following expression
+!bt
+\begin{equation*}
+\hat{p}_{k+1}=\hat{r}_k-\frac{\hat{p}_k^T \hat{A}\hat{r}_k}{\hat{p}_k^T\hat{A}\hat{p}_k} \hat{p}_k.
+\end{equation*}
+!et
+!eblock
+
+!split
+===== Conjugate gradient method ===== 
+!bblock
+We can also  compute the residual iteratively as
+!bt
+\begin{equation*}
+\hat{r}_{k+1}=\hat{b}-\hat{A}\hat{x}_{k+1},
+ \end{equation*}
+!et
+which equals
+!bt
+\begin{equation*}
+\hat{b}-\hat{A}(\hat{x}_k+\alpha_k\hat{p}_k),
+ \end{equation*}
+!et
+or
+!bt
+\begin{equation*}
+(\hat{b}-\hat{A}\hat{x}_k)-\alpha_k\hat{A}\hat{p}_k,
+ \end{equation*}
+!et
+which gives
+
+!bt
+\begin{equation*}
+\hat{r}_{k+1}=\hat{r}_k-\hat{A}\hat{p}_{k},
+ \end{equation*}
+!et
+!eblock
+
+
+
+!split
+===== Simple implementation of the Conjugate gradient algorithm =====
+!bblock
+!bc cppcod
+  Vector ConjugateGradient(Matrix A, Vector b, Vector x0){
+  int dim = x0.Dimension();
+  const double tolerance = 1.0e-14;
+  Vector x(dim),r(dim),v(dim),z(dim);
+  double c,t,d;
+
+  x = x0;
+  r = b - A*x;
+  v = r;
+  c = dot(r,r);
+  int i = 0; IterMax = dim;
+  while(i <= IterMax){
+    z = A*v;
+    t = c/dot(v,z);
+    x = x + t*v;
+    r = r - t*z;
+    d = dot(r,r);
+    if(sqrt(d) < tolerance)
+      break;
+    v = r + (d/c)*v;
+    c = d;  i++;
+  }
+  return x;
+} 
+!ec
+!eblock
+
+
+!split
+===== Broyden–Fletcher–Goldfarb–Shanno algorithm =====
+!bblock
+The optimization problem is to minimize $f(\mathbf {x} )$ where $\mathbf {x}$  is a vector in $R^{n}$, and $f$ is a differentiable scalar function. There are no constraints on the values that  $\mathbf {x}$  can take.
+
+The algorithm begins at an initial estimate for the optimal value $\mathbf {x}_{0}$ and proceeds iteratively to get a better estimate at each stage.
+
+The search direction $p_k$ at stage $k$ is given by the solution of the analogue of the Newton equation
+!bt
+\[
+B_{k}\mathbf {p} _{k}=-\nabla f(\mathbf {x}_{k}),
+\]
+!et
+
+where $B_{k}$ is an approximation to the Hessian matrix, which is
+updated iteratively at each stage, and $\nabla f(\mathbf {x} _{k})$
+is the gradient of the function
+evaluated at $x_k$. 
+A line search in the direction $p_k$ is then used to
+find the next point $x_{k+1}$ by minimising 
+!bt
+\[
+f(\mathbf {x}_{k}+\alpha \mathbf {p}_{k}),
+\]
+!et
+over the scalar $\alpha > 0$.
+
+!eblock
+
+

From c5cc89e62064067083a5f14b00bdb7eafe43bd43 Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Sun, 7 Oct 2018 20:49:24 +0200
Subject: [PATCH 4/6] more addition to gradient methods

---
 doc/src/Splines/Splines.do.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/src/Splines/Splines.do.txt b/doc/src/Splines/Splines.do.txt
index a71620b87..8e8a86700 100644
--- a/doc/src/Splines/Splines.do.txt
+++ b/doc/src/Splines/Splines.do.txt
@@ -496,7 +496,8 @@ leading to the iterative scheme
 !eblock
 
 
-
+!split
+=====  Code examples for steepest descent =====
 
 !split
 ===== Simple codes for  steepest descent and conjugate gradient using a $2\times 2$ matrix, in c++, Python code to come =====

From 20d4f2fb02f59ec7b5140ff117b3a50a32548ea4 Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Mon, 8 Oct 2018 10:46:35 +0200
Subject: [PATCH 5/6] Setting up project 2

---
 .../Projects/2018/Project2/Project2.do.txt    | 215 ++++++++++++++++++
 doc/src/Projects/2018/Project2/clean.sh       |   3 +
 doc/src/Projects/2018/Project2/make.sh        |  79 +++++++
 3 files changed, 297 insertions(+)
 create mode 100644 doc/src/Projects/2018/Project2/Project2.do.txt
 create mode 100755 doc/src/Projects/2018/Project2/clean.sh
 create mode 100755 doc/src/Projects/2018/Project2/make.sh

diff --git a/doc/src/Projects/2018/Project2/Project2.do.txt b/doc/src/Projects/2018/Project2/Project2.do.txt
new file mode 100644
index 000000000..27ce7ff3c
--- /dev/null
+++ b/doc/src/Projects/2018/Project2/Project2.do.txt
@@ -0,0 +1,215 @@
+TITLE: Project 2 on Machine Learning, deadline November 5
+AUTHOR: "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html" {copyright, 1999-present|CC BY-NC} at Department of Physics, University of Oslo, Norway
+DATE: today
+
+
+===== Classification and Regression, from linear and logistic regression to neural networks  =====
+
+The main aim of this project is to study both classification and
+regression problems, starting with the regression algortihms studied
+in project 1. We will include logistic regresion for classification
+problems and write our own multilayer perceptron code for studying
+both regression and classification problems.  The codes developed in
+project 1, including bootstrap and/or cross-validation as well as the
+computation of the mean-squared error and the R2 score function can
+also be utilized (and included in logistic regression and the neural
+network codes) in the present analysis.
+
+We will use the Ising model to generate our training data and will
+focus mainly on supervised training. We will follow closely the recent
+article of "Mehta et al, arXiv
+1803.08823":"https://arxiv.org/abs/1803.08823". This article stands
+out as an excellent review on machine learning (ML) algorithms applied
+to typical physics problems. The added benefit is that each figure and
+model presented in "this article is accompanied by its jupyter
+notebook":"https://physics.bu.edu/~pankajm/MLnotebooks.html". This
+means that we can start using these and compare with our own
+results. In case you wish to use their data for the Ising model, their
+data can be downloaded from the same link which lists to the jupyter
+notebooks. See also at the end of the project description for more
+information on how to install various Python packages.
+
+
+
+With the abovementioned configurations we will determine, using first
+various regression methods, the value of the coupling constant for the
+energy of the one-dimensional Ising model. Thereafter, we will use the
+two-dimensional data, but now computed at different temperatures, in
+order to classify the phase of the Ising model. Below the critical
+temperature, the system will be in a so-called ferromagnetic
+phase. Close to the critical temperature, the final magnetization
+becomes smaller and smaller in absolute value while above the critical
+temperature, the net magnetization is zero.  This classification case,
+that is the two-dimensional Ising model, will be studied using
+logistic regression and deep neural networks.  The aim is to develop
+your own logistic regression code for the classification of the phases
+(this is a binary model) and your multilayer perceptron code for the
+classification and regression case.
+
+
+Feel free to use the notebooks to benchmark your code.  If you wish to
+write your own C++ or Fortran program for say a simple neural network
+model and a logistic regression model, please feel free to do so.  You can then benchmark your results
+against the above jupyter notebooks.
+
+
+=== Part a): Producing the data  ===
+
+You can use the Ising model data from the article of Mehta *et al.*,
+or generate your own data.  If you opt for using your own Ising model
+code, you need to generate $10000$ energy configurations with their
+spin orientations after the system has reached its most likely
+state. These energies and their corresponding spin orientations
+represent then your data.  We will use a fixed lattice of $L\times L =
+40 \times 40$ spins in two dimensions and $L=40$ spins in one
+dimension.  Make sure the calculations have been equilibrated. For the
+two-dimensional system, compute the configurations for three values of
+the temperature, namely $T=0.75$ (ordered phase), $T=2.3$ (near the
+critical point) and $T=4.0$ (disordered phase).  For the
+one-dimensional system it suffices to compute the various
+configurations for one temperature only, say $T=2.0$.  These are the
+data you will use to study different ML algorithms.  We generate our
+data with $J=1$.
+
+=== Part b): Estimating the coupling constant of the one-dimensional Ising model  ===
+
+We start with the one-dimensional Ising model and use the data we have
+generated with $J=1$. Use linear regression, Lasso and Ridge
+regression as described section 6 and in Notebook 4 of "Mehta *et
+al.*":"https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVI-linreg_ising.html". Discuss
+the methods and how they perform in computing the coupling constant
+$J$. Give a critical analysis and discuss how to evaluate the *cost
+function*. You should feel free to write your own code, see also the
+lecture notes of
+"FYS-STK4155":"https://compphysics.github.io/MachineLearning/doc/web/course.html",
+in particular te material on least square methods.  You can use
+scikit-learn to perform these analyses. See below for instruction on
+how to install scikit-learn.
+
+=== Part c): Determine the phase of the two-dimensional Ising model  ===
+
+We switch now to binary classification methods and use logistic
+regression to define the phases of the Ising model.  Use described
+section 7 and in Notebook 6 of "Mehta *et
+al.*":"https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVII-logreg_ising.html". Discuss
+the methods and how they perform. Give a critical analysis and discuss
+how to evaluate the *cost function*. You should feel free to write
+your own code. 
+
+
+=== Part d): Classifying the Ising model phase using neural networks  ===
+
+We end the classification problem of the phases of the Ising model by
+employing the algorithm for so-called feed-forward deep neural
+networks (see section 9 of Mehta *et al.*). The method is described in
+"notebook
+12":"https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CIX-DNN_ising_TFlow.html".
+
+You can use tensorflow  to perform these analyses. See below for instruction on how to install tensorflow.
+
+===== Background literature =====
+
+
+o  The textbook of "Trevor Hastie, Robert Tibshirani, Jerome H. Friedman, The Elements of Statistical Learning, Springer":"https://www.springer.com/gp/book/9780387848570", chapters 3 and 7 are the most relevant ones for the analysis here. 
+
+o  "Mehta et al, arXiv 1803.08823":"https://arxiv.org/abs/1803.08823", *A high-bias, low-variance introduction to Machine Learning for physicists*, ArXiv:1803.08823.
+
+If you wish to read more about the Ising model and statistical physics here are three suggestions.
+
+o  "M. Plischke and B. Bergersen":"http://www.worldscientific.com/worldscibooks/10.1142/5660", *Equilibrium Statistical Physics*, World Scientific, see chapters 5 and 6.
+
+o  "D. P. Landau and K. Binder":"http://www.cambridge.org/no/academic/subjects/physics/computational-science-and-modelling/guide-monte-carlo-simulations-statistical-physics-4th-edition?format=HB", *A Guide to Monte Carlo Simulations in Statistical Physics*, Cambridge, see chapters 2,3 and 4.
+
+o  "M. E. J. Newman and T. Barkema":"https://global.oup.com/academic/product/monte-carlo-methods-in-statistical-physics-9780198517979?cc=no&lang=en&", *Monte Carlo Methods in Statistical Physics*, Oxford, see chapters 3 and 4.
+
+
+
+
+
+===== Introduction to numerical projects =====
+
+Here follows a brief recipe and recommendation on how to write a report for each
+project.
+
+  * Give a short description of the nature of the problem and the eventual  numerical methods you have used.
+
+  * Describe the algorithm you have used and/or developed. Here you may find it convenient to use pseudocoding. In many cases you can describe the algorithm in the program itself.
+
+  * Include the source code of your program. Comment your program properly.
+
+  * If possible, try to find analytic solutions, or known limits in order to test your program when developing the code.
+
+  * Include your results either in figure form or in a table. Remember to        label your results. All tables and figures should have relevant captions        and labels on the axes.
+
+  * Try to evaluate the reliabilty and numerical stability/precision of your results. If possible, include a qualitative and/or quantitative discussion of the numerical stability, eventual loss of precision etc.
+
+  * Try to give an interpretation of you results in your answers to  the problems.
+
+  * Critique: if possible include your comments and reflections about the  exercise, whether you felt you learnt something, ideas for improvements and  other thoughts you've made when solving the exercise. We wish to keep this course at the interactive level and your comments can help us improve it.
+
+  * Try to establish a practice where you log your work at the  computerlab. You may find such a logbook very handy at later stages in your work, especially when you don't properly remember  what a previous test version  of your program did. Here you could also record  the time spent on solving the exercise, various algorithms you may have tested or other topics which you feel worthy of mentioning.
+
+
+
+
+
+===== Format for electronic delivery of report and programs =====
+
+The preferred format for the report is a PDF file. You can also use DOC or postscript formats or as an ipython notebook file.  As programming language we prefer that you choose between C/C++, Fortran2008 or Python. The following prescription should be followed when preparing the report:
+
+  * Use Devilry to hand in your projects, log in  at  URL:"http://devilry.ifi.uio.no" with your normal UiO username and password and choose either 'fysstk3155' or 'fysstk4155'. There you can load up the files within the deadline.
+
+  * Upload _only_ the report file!  For the source code file(s) you have developed please provide us with your link to your github domain.  The report file should include all of your discussions and a list of the codes you have developed.  Do not include library files which are available at the course homepage, unless you have made specific changes to them.
+
+  * In your git repository, please include a folder which contains selected results. These can be in the form of output from your code for a selected set of runs and input parameters.
+
+  * In this and all later projects, you should include tests (for example unit tests) of your code(s).
+
+  * Comments  from us on your projects, approval or not, corrections to be made  etc can be found under your Devilry domain and are only visible to you and the teachers of the course.
+
+
+
+Finally, 
+we encourage you to collaborate. Optimal working groups consist of 
+2-3 students. You can then hand in a common report. 
+
+
+
+===== Software and needed installations =====
+
+If you have Python installed (we recommend Python3) and you feel pretty familiar with installing different packages, 
+we recommend that you install the following Python packages via _pip_ as
+o pip install numpy scipy matplotlib ipython scikit-learn tensorflow sympy pandas pillow
+For Python3, replace _pip_ with _pip3_.
+
+See below for a discussion of _tensorflow_ and _scikit-learn_. 
+
+For OSX users we recommend also, after having installed Xcode, to install _brew_. Brew allows 
+for a seamless installation of additional software via for example
+o brew install python3
+
+For Linux users, with its variety of distributions like for example the widely popular Ubuntu distribution
+you can use _pip_ as well and simply install Python as 
+o sudo apt-get install python3  (or python for python2.7)
+etc etc. 
+
+If you don't want to install various Python packages with their dependencies separately, we recommend two widely used distrubutions which set up  all relevant dependencies for Python, namely
+o "Anaconda":"https://docs.anaconda.com/" Anaconda is an open source distribution of the Python and R programming languages for large-scale data processing, predictive analytics, and scientific computing, that aims to simplify package management and deployment. Package versions are managed by the package management system _conda_
+o "Enthought canopy":"https://www.enthought.com/product/canopy/"  is a Python distribution for scientific and analytic computing distribution and analysis environment, available for free and under a commercial license.
+
+Popular software packages written in Python for ML are
+
+* "Scikit-learn":"http://scikit-learn.org/stable/", 
+* "Tensorflow":"https://www.tensorflow.org/",
+* "PyTorch":"http://pytorch.org/" and 
+* "Keras":"https://keras.io/".
+These are all freely available at their respective GitHub sites. They 
+encompass communities of developers in the thousands or more. And the number
+of code developers and contributors keeps increasing.
+
+
+
+
+
+
+
diff --git a/doc/src/Projects/2018/Project2/clean.sh b/doc/src/Projects/2018/Project2/clean.sh
new file mode 100755
index 000000000..2e5da2c72
--- /dev/null
+++ b/doc/src/Projects/2018/Project2/clean.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+doconce clean
+rm -rf *.pdf *.tex ipynb*.tar.gz *.html ._*.html *~ reveal.js Trash README.txt
diff --git a/doc/src/Projects/2018/Project2/make.sh b/doc/src/Projects/2018/Project2/make.sh
new file mode 100755
index 000000000..cf5d38365
--- /dev/null
+++ b/doc/src/Projects/2018/Project2/make.sh
@@ -0,0 +1,79 @@
+#!/bin/sh
+set -x
+
+function system {
+  "$@"
+  if [ $? -ne 0 ]; then
+    echo "make.sh: unsuccessful command $@"
+    echo "abort!"
+    exit 1
+  fi
+}
+
+if [ $# -eq 0 ]; then
+echo 'bash make.sh slides1|slides2'
+exit 1
+fi
+
+name=$1
+rm -f *.tar.gz
+
+opt="--encoding=utf-8"
+opt=
+
+rm -f *.aux
+
+
+
+# Plain HTML documents
+html=${name}
+system doconce format html $name --pygments_html_style=default --html_style=bloodish --html_links_in_new_window --html_output=$html $opt
+system doconce split_html $html.html --method=space10
+
+# Bootstrap style
+html=${name}-bs
+system doconce format html $name --html_style=bootstrap --pygments_html_style=default --html_admon=bootstrap_panel --html_output=$html $opt
+system doconce split_html $html.html --method=split --pagination --nav_button=bottom
+
+
+# Ordinary plain LaTeX document
+system doconce format pdflatex $name --print_latex_style=trac --latex_admon=paragraph $opt
+system doconce ptex2tex $name envir=print
+# Add special packages
+doconce subst "% Add user's preamble" "\g<1>\n\\usepackage{simplewick}" $name.tex
+doconce replace 'section{' 'section*{' $name.tex
+pdflatex -shell-escape $name
+pdflatex -shell-escape $name
+mv -f $name.pdf ${name}.pdf
+cp $name.tex ${name}.tex
+
+# Publish
+dest=../../../../Projects/2018
+if [ ! -d $dest/$name ]; then
+mkdir $dest/$name
+mkdir $dest/$name/pdf
+mkdir $dest/$name/html
+mkdir $dest/$name/ipynb
+fi
+cp ${name}*.tex $dest/$name/pdf
+cp ${name}*.pdf $dest/$name/pdf
+cp -r ${name}*.html ._${name}*.html $dest/$name/html
+
+# Figures: cannot just copy link, need to physically copy the files
+if [ -d fig-${name} ]; then
+if [ ! -d $dest/$name/html/fig-$name ]; then
+mkdir $dest/$name/html/fig-$name
+fi
+cp -r fig-${name}/* $dest/$name/html/fig-$name
+fi
+
+cp ${name}.ipynb $dest/$name/ipynb
+ipynb_tarfile=ipynb-${name}-src.tar.gz
+if [ ! -f ${ipynb_tarfile} ]; then
+cat > README.txt <<EOF
+This IPython notebook ${name}.ipynb does not require any additional
+programs.
+EOF
+tar czf ${ipynb_tarfile} README.txt
+fi
+cp ${ipynb_tarfile} $dest/$name/ipynb

From 5afd5ac5a33c8580477128e9ba05adde8648b8ed Mon Sep 17 00:00:00 2001
From: mhjensen <morten.hjorth-jensen@fys.uio.no>
Date: Mon, 8 Oct 2018 10:53:26 +0200
Subject: [PATCH 6/6] preliminary version of project 2, need more material

---
 .../2018/Project2/html/Project2-bs.html       | 403 +++++++++++++++++
 doc/Projects/2018/Project2/html/Project2.html | 343 +++++++++++++++
 .../Project2/ipynb/ipynb-Project2-src.tar.gz  | Bin 0 -> 211 bytes
 doc/Projects/2018/Project2/pdf/Project2.p.tex | 406 ++++++++++++++++++
 doc/Projects/2018/Project2/pdf/Project2.pdf   | Bin 0 -> 210950 bytes
 doc/Projects/2018/Project2/pdf/Project2.tex   | 378 ++++++++++++++++
 .../Projects/2018/Project2/Project2.do.txt    |   5 +
 7 files changed, 1535 insertions(+)
 create mode 100644 doc/Projects/2018/Project2/html/Project2-bs.html
 create mode 100644 doc/Projects/2018/Project2/html/Project2.html
 create mode 100644 doc/Projects/2018/Project2/ipynb/ipynb-Project2-src.tar.gz
 create mode 100644 doc/Projects/2018/Project2/pdf/Project2.p.tex
 create mode 100644 doc/Projects/2018/Project2/pdf/Project2.pdf
 create mode 100644 doc/Projects/2018/Project2/pdf/Project2.tex

diff --git a/doc/Projects/2018/Project2/html/Project2-bs.html b/doc/Projects/2018/Project2/html/Project2-bs.html
new file mode 100644
index 000000000..952a509fa
--- /dev/null
+++ b/doc/Projects/2018/Project2/html/Project2-bs.html
@@ -0,0 +1,403 @@
+<!--
+Automatically generated HTML file from DocOnce source
+(https://github.com/hplgit/doconce/)
+-->
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="generator" content="DocOnce: https://github.com/hplgit/doconce/" />
+<meta name="description" content="Project 2 on Machine Learning, deadline November 5">
+
+<title>Project 2 on Machine Learning, deadline November 5</title>
+
+<!-- Bootstrap style: bootstrap -->
+<link href="https://netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" rel="stylesheet">
+<!-- not necessary
+<link href="https://netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
+-->
+
+<style type="text/css">
+
+/* Add scrollbar to dropdown menus in bootstrap navigation bar */
+.dropdown-menu {
+   height: auto;
+   max-height: 400px;
+   overflow-x: hidden;
+}
+
+/* Adds an invisible element before each target to offset for the navigation
+   bar */
+.anchor::before {
+  content:"";
+  display:block;
+  height:50px;      /* fixed header height for style bootstrap */
+  margin:-50px 0 0; /* negative fixed header height */
+}
+</style>
+
+
+</head>
+
+<!-- tocinfo
+{'highest level': 2,
+ 'sections': [('Classification and Regression, from linear and logistic '
+               'regression to neural networks',
+               2,
+               None,
+               '___sec0'),
+              ('Part a): Producing the data', 3, None, '___sec1'),
+              ('Part b): Estimating the coupling constant of the '
+               'one-dimensional Ising model',
+               3,
+               None,
+               '___sec2'),
+              ('Part c): Determine the phase of the two-dimensional Ising '
+               'model',
+               3,
+               None,
+               '___sec3'),
+              ('Part d): Classifying the Ising model phase using neural '
+               'networks',
+               3,
+               None,
+               '___sec4'),
+              ('Background literature', 2, None, '___sec5'),
+              ('Introduction to numerical projects', 2, None, '___sec6'),
+              ('Format for electronic delivery of report and programs',
+               2,
+               None,
+               '___sec7'),
+              ('Software and needed installations', 2, None, '___sec8')]}
+end of tocinfo -->
+
+<body>
+
+
+
+<script type="text/x-mathjax-config">
+MathJax.Hub.Config({
+  TeX: {
+     equationNumbers: {  autoNumber: "none"  },
+     extensions: ["AMSmath.js", "AMSsymbols.js", "autobold.js", "color.js"]
+  }
+});
+</script>
+<script type="text/javascript" async
+ src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+</script>
+
+
+
+    
+<!-- Bootstrap navigation bar -->
+<div class="navbar navbar-default navbar-fixed-top">
+  <div class="navbar-header">
+    <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-responsive-collapse">
+      <span class="icon-bar"></span>
+      <span class="icon-bar"></span>
+      <span class="icon-bar"></span>
+    </button>
+    <a class="navbar-brand" href="Project2-bs.html">Project 2 on Machine Learning, deadline November 5</a>
+  </div>
+
+  <div class="navbar-collapse collapse navbar-responsive-collapse">
+    <ul class="nav navbar-nav navbar-right">
+      <li class="dropdown">
+        <a href="#" class="dropdown-toggle" data-toggle="dropdown">Contents <b class="caret"></b></a>
+        <ul class="dropdown-menu">
+     <!-- navigation toc: --> <li><a href="#___sec0" style="font-size: 80%;"><b>Classification and Regression, from linear and logistic regression to neural networks</b></a></li>
+     <!-- navigation toc: --> <li><a href="#___sec1" style="font-size: 80%;">&nbsp;&nbsp;&nbsp;Part a): Producing the data</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec2" style="font-size: 80%;">&nbsp;&nbsp;&nbsp;Part b): Estimating the coupling constant of the one-dimensional Ising model</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec3" style="font-size: 80%;">&nbsp;&nbsp;&nbsp;Part c): Determine the phase of the two-dimensional Ising model</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec4" style="font-size: 80%;">&nbsp;&nbsp;&nbsp;Part d): Classifying the Ising model phase using neural networks</a></li>
+     <!-- navigation toc: --> <li><a href="#___sec5" style="font-size: 80%;"><b>Background literature</b></a></li>
+     <!-- navigation toc: --> <li><a href="#___sec6" style="font-size: 80%;"><b>Introduction to numerical projects</b></a></li>
+     <!-- navigation toc: --> <li><a href="#___sec7" style="font-size: 80%;"><b>Format for electronic delivery of report and programs</b></a></li>
+     <!-- navigation toc: --> <li><a href="#___sec8" style="font-size: 80%;"><b>Software and needed installations</b></a></li>
+
+        </ul>
+      </li>
+    </ul>
+  </div>
+</div>
+</div> <!-- end of navigation bar -->
+
+<div class="container">
+
+<p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p> <!-- add vertical space -->
+
+<a name="part0000"></a>
+<!-- ------------------- main content ---------------------- -->
+
+
+
+<div class="jumbotron">
+<center><h1>Project 2 on Machine Learning, deadline November 5</h1></center>  <!-- document title -->
+
+<p>
+<!-- author(s): <a href="http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html" target="_self">Data Analysis and Machine Learning FYS-STK3155/FYS4155</a> -->
+
+<center>
+<b><a href="http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html" target="_self">Data Analysis and Machine Learning FYS-STK3155/FYS4155</a></b> 
+</center>
+
+<p>
+<!-- institution -->
+
+<center><b>Department of Physics, University of Oslo, Norway</b></center>
+<br>
+<p>
+<center><h4>Oct 8, 2018</h4></center> <!-- date -->
+<br>
+<ol>
+<li> add about ising model</li>
+<li> link to where we have the data</li>
+<li> explain how to fit the model</li>
+<li> link to mehta's article</li>
+</ol>
+
+
+
+</div> <!-- end jumbotron -->
+
+<h2 id="___sec0" class="anchor">Classification and Regression, from linear and logistic regression to neural networks  </h2>
+
+<p>
+The main aim of this project is to study both classification and
+regression problems, starting with the regression algortihms studied
+in project 1. We will include logistic regresion for classification
+problems and write our own multilayer perceptron code for studying
+both regression and classification problems.  The codes developed in
+project 1, including bootstrap and/or cross-validation as well as the
+computation of the mean-squared error and the R2 score function can
+also be utilized (and included in logistic regression and the neural
+network codes) in the present analysis.
+
+<p>
+We will use the Ising model to generate our training data and will
+focus mainly on supervised training. We will follow closely the recent
+article of <a href="https://arxiv.org/abs/1803.08823" target="_self">Mehta et al, arXiv
+1803.08823</a>. This article stands
+out as an excellent review on machine learning (ML) algorithms applied
+to typical physics problems. The added benefit is that each figure and
+model presented in <a href="https://physics.bu.edu/~pankajm/MLnotebooks.html" target="_self">this article is accompanied by its jupyter
+notebook</a>. This
+means that we can start using these and compare with our own
+results. In case you wish to use their data for the Ising model, their
+data can be downloaded from the same link which lists to the jupyter
+notebooks. See also at the end of the project description for more
+information on how to install various Python packages.
+
+<p>
+With the abovementioned configurations we will determine, using first
+various regression methods, the value of the coupling constant for the
+energy of the one-dimensional Ising model. Thereafter, we will use the
+two-dimensional data, but now computed at different temperatures, in
+order to classify the phase of the Ising model. Below the critical
+temperature, the system will be in a so-called ferromagnetic
+phase. Close to the critical temperature, the final magnetization
+becomes smaller and smaller in absolute value while above the critical
+temperature, the net magnetization is zero.  This classification case,
+that is the two-dimensional Ising model, will be studied using
+logistic regression and deep neural networks.  The aim is to develop
+your own logistic regression code for the classification of the phases
+(this is a binary model) and your multilayer perceptron code for the
+classification and regression case.
+
+<p>
+Feel free to use the notebooks to benchmark your code.  If you wish to
+write your own C++ or Fortran program for say a simple neural network
+model and a logistic regression model, please feel free to do so.  You can then benchmark your results
+against the above jupyter notebooks.
+
+<h3 id="___sec1" class="anchor">Part a): Producing the data  </h3>
+
+<p>
+You can use the Ising model data from the article of Mehta <em>et al.</em>,
+or generate your own data.  If you opt for using your own Ising model
+code, you need to generate \( 10000 \) energy configurations with their
+spin orientations after the system has reached its most likely
+state. These energies and their corresponding spin orientations
+represent then your data.  We will use a fixed lattice of \( L\times L =
+40 \times 40 \) spins in two dimensions and \( L=40 \) spins in one
+dimension.  Make sure the calculations have been equilibrated. For the
+two-dimensional system, compute the configurations for three values of
+the temperature, namely \( T=0.75 \) (ordered phase), \( T=2.3 \) (near the
+critical point) and \( T=4.0 \) (disordered phase).  For the
+one-dimensional system it suffices to compute the various
+configurations for one temperature only, say \( T=2.0 \).  These are the
+data you will use to study different ML algorithms.  We generate our
+data with \( J=1 \).
+
+<h3 id="___sec2" class="anchor">Part b): Estimating the coupling constant of the one-dimensional Ising model  </h3>
+
+<p>
+We start with the one-dimensional Ising model and use the data we have
+generated with \( J=1 \). Use linear regression, Lasso and Ridge
+regression as described section 6 and in Notebook 4 of <a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVI-linreg_ising.html" target="_self">Mehta *et
+al.*</a>. Discuss
+the methods and how they perform in computing the coupling constant
+\( J \). Give a critical analysis and discuss how to evaluate the <em>cost
+function</em>. You should feel free to write your own code, see also the
+lecture notes of
+<a href="https://compphysics.github.io/MachineLearning/doc/web/course.html" target="_self">FYS-STK4155</a>,
+in particular te material on least square methods.  You can use
+scikit-learn to perform these analyses. See below for instruction on
+how to install scikit-learn.
+
+<h3 id="___sec3" class="anchor">Part c): Determine the phase of the two-dimensional Ising model  </h3>
+
+<p>
+We switch now to binary classification methods and use logistic
+regression to define the phases of the Ising model.  Use described
+section 7 and in Notebook 6 of <a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVII-logreg_ising.html" target="_self">Mehta *et
+al.*</a>. Discuss
+the methods and how they perform. Give a critical analysis and discuss
+how to evaluate the <em>cost function</em>. You should feel free to write
+your own code.
+
+<h3 id="___sec4" class="anchor">Part d): Classifying the Ising model phase using neural networks  </h3>
+
+<p>
+We end the classification problem of the phases of the Ising model by
+employing the algorithm for so-called feed-forward deep neural
+networks (see section 9 of Mehta <em>et al.</em>). The method is described in
+<a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CIX-DNN_ising_TFlow.html" target="_self">notebook
+12</a>.
+
+<p>
+You can use tensorflow  to perform these analyses. See below for instruction on how to install tensorflow.
+
+<h2 id="___sec5" class="anchor">Background literature </h2>
+
+<ol>
+<li> The textbook of <a href="https://www.springer.com/gp/book/9780387848570" target="_self">Trevor Hastie, Robert Tibshirani, Jerome H. Friedman, The Elements of Statistical Learning, Springer</a>, chapters 3 and 7 are the most relevant ones for the analysis here.</li> 
+<li> <a href="https://arxiv.org/abs/1803.08823" target="_self">Mehta et al, arXiv 1803.08823</a>, <em>A high-bias, low-variance introduction to Machine Learning for physicists</em>, ArXiv:1803.08823.</li>
+</ol>
+
+If you wish to read more about the Ising model and statistical physics here are three suggestions.
+
+<ol>
+<li> <a href="http://www.worldscientific.com/worldscibooks/10.1142/5660" target="_self">M. Plischke and B. Bergersen</a>, <em>Equilibrium Statistical Physics</em>, World Scientific, see chapters 5 and 6.</li>
+<li> <a href="http://www.cambridge.org/no/academic/subjects/physics/computational-science-and-modelling/guide-monte-carlo-simulations-statistical-physics-4th-edition?format=HB" target="_self">D. P. Landau and K. Binder</a>, <em>A Guide to Monte Carlo Simulations in Statistical Physics</em>, Cambridge, see chapters 2,3 and 4.</li>
+<li> <a href="https://global.oup.com/academic/product/monte-carlo-methods-in-statistical-physics-9780198517979?cc=no&lang=en&" target="_self">M. E. J. Newman and T. Barkema</a>, <em>Monte Carlo Methods in Statistical Physics</em>, Oxford, see chapters 3 and 4.</li>
+</ol>
+
+<h2 id="___sec6" class="anchor">Introduction to numerical projects </h2>
+
+<p>
+Here follows a brief recipe and recommendation on how to write a report for each
+project.
+
+<ul>
+  <li> Give a short description of the nature of the problem and the eventual  numerical methods you have used.</li>
+  <li> Describe the algorithm you have used and/or developed. Here you may find it convenient to use pseudocoding. In many cases you can describe the algorithm in the program itself.</li>
+  <li> Include the source code of your program. Comment your program properly.</li>
+  <li> If possible, try to find analytic solutions, or known limits in order to test your program when developing the code.</li>
+  <li> Include your results either in figure form or in a table. Remember to        label your results. All tables and figures should have relevant captions        and labels on the axes.</li>
+  <li> Try to evaluate the reliabilty and numerical stability/precision of your results. If possible, include a qualitative and/or quantitative discussion of the numerical stability, eventual loss of precision etc.</li>
+  <li> Try to give an interpretation of you results in your answers to  the problems.</li>
+  <li> Critique: if possible include your comments and reflections about the  exercise, whether you felt you learnt something, ideas for improvements and  other thoughts you've made when solving the exercise. We wish to keep this course at the interactive level and your comments can help us improve it.</li>
+  <li> Try to establish a practice where you log your work at the  computerlab. You may find such a logbook very handy at later stages in your work, especially when you don't properly remember  what a previous test version  of your program did. Here you could also record  the time spent on solving the exercise, various algorithms you may have tested or other topics which you feel worthy of mentioning.</li>
+</ul>
+
+<h2 id="___sec7" class="anchor">Format for electronic delivery of report and programs </h2>
+
+<p>
+The preferred format for the report is a PDF file. You can also use DOC or postscript formats or as an ipython notebook file.  As programming language we prefer that you choose between C/C++, Fortran2008 or Python. The following prescription should be followed when preparing the report:
+
+<ul>
+  <li> Use Devilry to hand in your projects, log in  at  <a href="http://devilry.ifi.uio.no" target="_self"><tt>http://devilry.ifi.uio.no</tt></a> with your normal UiO username and password and choose either 'fysstk3155' or 'fysstk4155'. There you can load up the files within the deadline.</li>
+  <li> Upload <b>only</b> the report file!  For the source code file(s) you have developed please provide us with your link to your github domain.  The report file should include all of your discussions and a list of the codes you have developed.  Do not include library files which are available at the course homepage, unless you have made specific changes to them.</li>
+  <li> In your git repository, please include a folder which contains selected results. These can be in the form of output from your code for a selected set of runs and input parameters.</li>
+  <li> In this and all later projects, you should include tests (for example unit tests) of your code(s).</li>
+  <li> Comments  from us on your projects, approval or not, corrections to be made  etc can be found under your Devilry domain and are only visible to you and the teachers of the course.</li>
+</ul>
+
+Finally, 
+we encourage you to collaborate. Optimal working groups consist of 
+2-3 students. You can then hand in a common report.
+
+<h2 id="___sec8" class="anchor">Software and needed installations </h2>
+
+<p>
+If you have Python installed (we recommend Python3) and you feel pretty familiar with installing different packages, 
+we recommend that you install the following Python packages via <b>pip</b> as
+
+<ol>
+<li> pip install numpy scipy matplotlib ipython scikit-learn tensorflow sympy pandas pillow</li>
+</ol>
+
+For Python3, replace <b>pip</b> with <b>pip3</b>.
+
+<p>
+See below for a discussion of <b>tensorflow</b> and <b>scikit-learn</b>.
+
+<p>
+For OSX users we recommend also, after having installed Xcode, to install <b>brew</b>. Brew allows 
+for a seamless installation of additional software via for example
+
+<ol>
+<li> brew install python3</li>
+</ol>
+
+For Linux users, with its variety of distributions like for example the widely popular Ubuntu distribution
+you can use <b>pip</b> as well and simply install Python as 
+
+<ol>
+<li> sudo apt-get install python3  (or python for python2.7)</li>
+</ol>
+
+etc etc.
+
+<p>
+If you don't want to install various Python packages with their dependencies separately, we recommend two widely used distrubutions which set up  all relevant dependencies for Python, namely
+
+<ol>
+<li> <a href="https://docs.anaconda.com/" target="_self">Anaconda</a> Anaconda is an open source distribution of the Python and R programming languages for large-scale data processing, predictive analytics, and scientific computing, that aims to simplify package management and deployment. Package versions are managed by the package management system <b>conda</b></li>
+<li> <a href="https://www.enthought.com/product/canopy/" target="_self">Enthought canopy</a>  is a Python distribution for scientific and analytic computing distribution and analysis environment, available for free and under a commercial license.</li>
+</ol>
+
+Popular software packages written in Python for ML are
+
+<ul>
+<li> <a href="http://scikit-learn.org/stable/" target="_self">Scikit-learn</a>,</li> 
+<li> <a href="https://www.tensorflow.org/" target="_self">Tensorflow</a>,</li>
+<li> <a href="http://pytorch.org/" target="_self">PyTorch</a> and</li> 
+<li> <a href="https://keras.io/" target="_self">Keras</a>.</li>
+</ul>
+
+These are all freely available at their respective GitHub sites. They 
+encompass communities of developers in the thousands or more. And the number
+of code developers and contributors keeps increasing.
+
+<p>
+
+<p>
+<!-- navigation buttons at the bottom of the page -->
+<ul class="pagination">
+  <li class="active"><a href="._Project2-bs000.html">1</a></li>
+</ul>
+<!-- ------------------- end of main content --------------- -->
+
+</div>  <!-- end container -->
+<!-- include javascript, jQuery *first* -->
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+<script src="https://netdna.bootstrapcdn.com/bootstrap/3.0.0/js/bootstrap.min.js"></script>
+
+<!-- Bootstrap footer
+<footer>
+<a href="http://..."><img width="250" align=right src="http://..."></a>
+</footer>
+-->
+
+
+<center style="font-size:80%">
+<!-- copyright --> &copy; 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license
+</center>
+
+
+</body>
+</html>
+    
+
diff --git a/doc/Projects/2018/Project2/html/Project2.html b/doc/Projects/2018/Project2/html/Project2.html
new file mode 100644
index 000000000..2249e5a7a
--- /dev/null
+++ b/doc/Projects/2018/Project2/html/Project2.html
@@ -0,0 +1,343 @@
+<!--
+Automatically generated HTML file from DocOnce source
+(https://github.com/hplgit/doconce/)
+-->
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="generator" content="DocOnce: https://github.com/hplgit/doconce/" />
+<meta name="description" content="Project 2 on Machine Learning, deadline November 5">
+
+<title>Project 2 on Machine Learning, deadline November 5</title>
+
+
+<style type="text/css">
+/* bloodish style */
+
+body {
+  font-family: Helvetica, Verdana, Arial, Sans-serif;
+  color: #404040;
+  background: #ffffff;
+}
+h1 { font-size: 1.8em;  color: #8A0808; }
+h2 { font-size: 1.6em;  color: #8A0808; }
+h3 { font-size: 1.4em;  color: #8A0808; }
+h4 { color: #8A0808; }
+a { color: #8A0808; text-decoration:none; }
+tt { font-family: "Courier New", Courier; }
+/* pre style removed because it will interfer with pygments */
+p { text-indent: 0px; }
+hr { border: 0; width: 80%; border-bottom: 1px solid #aaa}
+p.caption { width: 80%; font-style: normal; text-align: left; }
+hr.figure { border: 0; width: 80%; border-bottom: 1px solid #aaa}
+
+div { text-align: justify; text-justify: inter-word; }
+</style>
+
+
+</head>
+
+<!-- tocinfo
+{'highest level': 2,
+ 'sections': [('Classification and Regression, from linear and logistic '
+               'regression to neural networks',
+               2,
+               None,
+               '___sec0'),
+              ('Part a): Producing the data', 3, None, '___sec1'),
+              ('Part b): Estimating the coupling constant of the '
+               'one-dimensional Ising model',
+               3,
+               None,
+               '___sec2'),
+              ('Part c): Determine the phase of the two-dimensional Ising '
+               'model',
+               3,
+               None,
+               '___sec3'),
+              ('Part d): Classifying the Ising model phase using neural '
+               'networks',
+               3,
+               None,
+               '___sec4'),
+              ('Background literature', 2, None, '___sec5'),
+              ('Introduction to numerical projects', 2, None, '___sec6'),
+              ('Format for electronic delivery of report and programs',
+               2,
+               None,
+               '___sec7'),
+              ('Software and needed installations', 2, None, '___sec8')]}
+end of tocinfo -->
+
+<body>
+
+
+
+<script type="text/x-mathjax-config">
+MathJax.Hub.Config({
+  TeX: {
+     equationNumbers: {  autoNumber: "AMS"  },
+     extensions: ["AMSmath.js", "AMSsymbols.js", "autobold.js", "color.js"]
+  }
+});
+</script>
+<script type="text/javascript" async
+ src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+</script>
+
+
+
+    
+<!-- ------------------- main content ---------------------- -->
+
+
+
+<center><h1>Project 2 on Machine Learning, deadline November 5</h1></center>  <!-- document title -->
+
+<p>
+<!-- author(s): <a href="http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html" target="_blank">Data Analysis and Machine Learning FYS-STK3155/FYS4155</a> -->
+
+<center>
+<b><a href="http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html" target="_blank">Data Analysis and Machine Learning FYS-STK3155/FYS4155</a></b> 
+</center>
+
+<p>
+<!-- institution -->
+
+<center><b>Department of Physics, University of Oslo, Norway</b></center>
+<br>
+<p>
+<center><h4>Oct 8, 2018</h4></center> <!-- date -->
+<br>
+<ol>
+<li> add about ising model</li>
+<li> link to where we have the data</li>
+<li> explain how to fit the model</li>
+<li> link to mehta's article</li>
+</ol>
+
+<h2 id="___sec0">Classification and Regression, from linear and logistic regression to neural networks  </h2>
+
+<p>
+The main aim of this project is to study both classification and
+regression problems, starting with the regression algortihms studied
+in project 1. We will include logistic regresion for classification
+problems and write our own multilayer perceptron code for studying
+both regression and classification problems.  The codes developed in
+project 1, including bootstrap and/or cross-validation as well as the
+computation of the mean-squared error and the R2 score function can
+also be utilized (and included in logistic regression and the neural
+network codes) in the present analysis.
+
+<p>
+We will use the Ising model to generate our training data and will
+focus mainly on supervised training. We will follow closely the recent
+article of <a href="https://arxiv.org/abs/1803.08823" target="_blank">Mehta et al, arXiv
+1803.08823</a>. This article stands
+out as an excellent review on machine learning (ML) algorithms applied
+to typical physics problems. The added benefit is that each figure and
+model presented in <a href="https://physics.bu.edu/~pankajm/MLnotebooks.html" target="_blank">this article is accompanied by its jupyter
+notebook</a>. This
+means that we can start using these and compare with our own
+results. In case you wish to use their data for the Ising model, their
+data can be downloaded from the same link which lists to the jupyter
+notebooks. See also at the end of the project description for more
+information on how to install various Python packages.
+
+<p>
+With the abovementioned configurations we will determine, using first
+various regression methods, the value of the coupling constant for the
+energy of the one-dimensional Ising model. Thereafter, we will use the
+two-dimensional data, but now computed at different temperatures, in
+order to classify the phase of the Ising model. Below the critical
+temperature, the system will be in a so-called ferromagnetic
+phase. Close to the critical temperature, the final magnetization
+becomes smaller and smaller in absolute value while above the critical
+temperature, the net magnetization is zero.  This classification case,
+that is the two-dimensional Ising model, will be studied using
+logistic regression and deep neural networks.  The aim is to develop
+your own logistic regression code for the classification of the phases
+(this is a binary model) and your multilayer perceptron code for the
+classification and regression case.
+
+<p>
+Feel free to use the notebooks to benchmark your code.  If you wish to
+write your own C++ or Fortran program for say a simple neural network
+model and a logistic regression model, please feel free to do so.  You can then benchmark your results
+against the above jupyter notebooks.
+
+<h3 id="___sec1">Part a): Producing the data  </h3>
+
+<p>
+You can use the Ising model data from the article of Mehta <em>et al.</em>,
+or generate your own data.  If you opt for using your own Ising model
+code, you need to generate \( 10000 \) energy configurations with their
+spin orientations after the system has reached its most likely
+state. These energies and their corresponding spin orientations
+represent then your data.  We will use a fixed lattice of \( L\times L =
+40 \times 40 \) spins in two dimensions and \( L=40 \) spins in one
+dimension.  Make sure the calculations have been equilibrated. For the
+two-dimensional system, compute the configurations for three values of
+the temperature, namely \( T=0.75 \) (ordered phase), \( T=2.3 \) (near the
+critical point) and \( T=4.0 \) (disordered phase).  For the
+one-dimensional system it suffices to compute the various
+configurations for one temperature only, say \( T=2.0 \).  These are the
+data you will use to study different ML algorithms.  We generate our
+data with \( J=1 \).
+
+<h3 id="___sec2">Part b): Estimating the coupling constant of the one-dimensional Ising model  </h3>
+
+<p>
+We start with the one-dimensional Ising model and use the data we have
+generated with \( J=1 \). Use linear regression, Lasso and Ridge
+regression as described section 6 and in Notebook 4 of <a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVI-linreg_ising.html" target="_blank">Mehta *et
+al.*</a>. Discuss
+the methods and how they perform in computing the coupling constant
+\( J \). Give a critical analysis and discuss how to evaluate the <em>cost
+function</em>. You should feel free to write your own code, see also the
+lecture notes of
+<a href="https://compphysics.github.io/MachineLearning/doc/web/course.html" target="_blank">FYS-STK4155</a>,
+in particular te material on least square methods.  You can use
+scikit-learn to perform these analyses. See below for instruction on
+how to install scikit-learn.
+
+<h3 id="___sec3">Part c): Determine the phase of the two-dimensional Ising model  </h3>
+
+<p>
+We switch now to binary classification methods and use logistic
+regression to define the phases of the Ising model.  Use described
+section 7 and in Notebook 6 of <a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVII-logreg_ising.html" target="_blank">Mehta *et
+al.*</a>. Discuss
+the methods and how they perform. Give a critical analysis and discuss
+how to evaluate the <em>cost function</em>. You should feel free to write
+your own code.
+
+<h3 id="___sec4">Part d): Classifying the Ising model phase using neural networks  </h3>
+
+<p>
+We end the classification problem of the phases of the Ising model by
+employing the algorithm for so-called feed-forward deep neural
+networks (see section 9 of Mehta <em>et al.</em>). The method is described in
+<a href="https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CIX-DNN_ising_TFlow.html" target="_blank">notebook
+12</a>.
+
+<p>
+You can use tensorflow  to perform these analyses. See below for instruction on how to install tensorflow.
+
+<h2 id="___sec5">Background literature </h2>
+
+<ol>
+<li> The textbook of <a href="https://www.springer.com/gp/book/9780387848570" target="_blank">Trevor Hastie, Robert Tibshirani, Jerome H. Friedman, The Elements of Statistical Learning, Springer</a>, chapters 3 and 7 are the most relevant ones for the analysis here.</li> 
+<li> <a href="https://arxiv.org/abs/1803.08823" target="_blank">Mehta et al, arXiv 1803.08823</a>, <em>A high-bias, low-variance introduction to Machine Learning for physicists</em>, ArXiv:1803.08823.</li>
+</ol>
+
+If you wish to read more about the Ising model and statistical physics here are three suggestions.
+
+<ol>
+<li> <a href="http://www.worldscientific.com/worldscibooks/10.1142/5660" target="_blank">M. Plischke and B. Bergersen</a>, <em>Equilibrium Statistical Physics</em>, World Scientific, see chapters 5 and 6.</li>
+<li> <a href="http://www.cambridge.org/no/academic/subjects/physics/computational-science-and-modelling/guide-monte-carlo-simulations-statistical-physics-4th-edition?format=HB" target="_blank">D. P. Landau and K. Binder</a>, <em>A Guide to Monte Carlo Simulations in Statistical Physics</em>, Cambridge, see chapters 2,3 and 4.</li>
+<li> <a href="https://global.oup.com/academic/product/monte-carlo-methods-in-statistical-physics-9780198517979?cc=no&lang=en&" target="_blank">M. E. J. Newman and T. Barkema</a>, <em>Monte Carlo Methods in Statistical Physics</em>, Oxford, see chapters 3 and 4.</li>
+</ol>
+
+<h2 id="___sec6">Introduction to numerical projects </h2>
+
+<p>
+Here follows a brief recipe and recommendation on how to write a report for each
+project.
+
+<ul>
+  <li> Give a short description of the nature of the problem and the eventual  numerical methods you have used.</li>
+  <li> Describe the algorithm you have used and/or developed. Here you may find it convenient to use pseudocoding. In many cases you can describe the algorithm in the program itself.</li>
+  <li> Include the source code of your program. Comment your program properly.</li>
+  <li> If possible, try to find analytic solutions, or known limits in order to test your program when developing the code.</li>
+  <li> Include your results either in figure form or in a table. Remember to        label your results. All tables and figures should have relevant captions        and labels on the axes.</li>
+  <li> Try to evaluate the reliabilty and numerical stability/precision of your results. If possible, include a qualitative and/or quantitative discussion of the numerical stability, eventual loss of precision etc.</li>
+  <li> Try to give an interpretation of you results in your answers to  the problems.</li>
+  <li> Critique: if possible include your comments and reflections about the  exercise, whether you felt you learnt something, ideas for improvements and  other thoughts you've made when solving the exercise. We wish to keep this course at the interactive level and your comments can help us improve it.</li>
+  <li> Try to establish a practice where you log your work at the  computerlab. You may find such a logbook very handy at later stages in your work, especially when you don't properly remember  what a previous test version  of your program did. Here you could also record  the time spent on solving the exercise, various algorithms you may have tested or other topics which you feel worthy of mentioning.</li>
+</ul>
+
+<h2 id="___sec7">Format for electronic delivery of report and programs </h2>
+
+<p>
+The preferred format for the report is a PDF file. You can also use DOC or postscript formats or as an ipython notebook file.  As programming language we prefer that you choose between C/C++, Fortran2008 or Python. The following prescription should be followed when preparing the report:
+
+<ul>
+  <li> Use Devilry to hand in your projects, log in  at  <a href="http://devilry.ifi.uio.no" target="_blank"><tt>http://devilry.ifi.uio.no</tt></a> with your normal UiO username and password and choose either 'fysstk3155' or 'fysstk4155'. There you can load up the files within the deadline.</li>
+  <li> Upload <b>only</b> the report file!  For the source code file(s) you have developed please provide us with your link to your github domain.  The report file should include all of your discussions and a list of the codes you have developed.  Do not include library files which are available at the course homepage, unless you have made specific changes to them.</li>
+  <li> In your git repository, please include a folder which contains selected results. These can be in the form of output from your code for a selected set of runs and input parameters.</li>
+  <li> In this and all later projects, you should include tests (for example unit tests) of your code(s).</li>
+  <li> Comments  from us on your projects, approval or not, corrections to be made  etc can be found under your Devilry domain and are only visible to you and the teachers of the course.</li>
+</ul>
+
+Finally, 
+we encourage you to collaborate. Optimal working groups consist of 
+2-3 students. You can then hand in a common report.
+
+<h2 id="___sec8">Software and needed installations </h2>
+
+<p>
+If you have Python installed (we recommend Python3) and you feel pretty familiar with installing different packages, 
+we recommend that you install the following Python packages via <b>pip</b> as
+
+<ol>
+<li> pip install numpy scipy matplotlib ipython scikit-learn tensorflow sympy pandas pillow</li>
+</ol>
+
+For Python3, replace <b>pip</b> with <b>pip3</b>.
+
+<p>
+See below for a discussion of <b>tensorflow</b> and <b>scikit-learn</b>.
+
+<p>
+For OSX users we recommend also, after having installed Xcode, to install <b>brew</b>. Brew allows 
+for a seamless installation of additional software via for example
+
+<ol>
+<li> brew install python3</li>
+</ol>
+
+For Linux users, with its variety of distributions like for example the widely popular Ubuntu distribution
+you can use <b>pip</b> as well and simply install Python as 
+
+<ol>
+<li> sudo apt-get install python3  (or python for python2.7)</li>
+</ol>
+
+etc etc.
+
+<p>
+If you don't want to install various Python packages with their dependencies separately, we recommend two widely used distrubutions which set up  all relevant dependencies for Python, namely
+
+<ol>
+<li> <a href="https://docs.anaconda.com/" target="_blank">Anaconda</a> Anaconda is an open source distribution of the Python and R programming languages for large-scale data processing, predictive analytics, and scientific computing, that aims to simplify package management and deployment. Package versions are managed by the package management system <b>conda</b></li>
+<li> <a href="https://www.enthought.com/product/canopy/" target="_blank">Enthought canopy</a>  is a Python distribution for scientific and analytic computing distribution and analysis environment, available for free and under a commercial license.</li>
+</ol>
+
+Popular software packages written in Python for ML are
+
+<ul>
+<li> <a href="http://scikit-learn.org/stable/" target="_blank">Scikit-learn</a>,</li> 
+<li> <a href="https://www.tensorflow.org/" target="_blank">Tensorflow</a>,</li>
+<li> <a href="http://pytorch.org/" target="_blank">PyTorch</a> and</li> 
+<li> <a href="https://keras.io/" target="_blank">Keras</a>.</li>
+</ul>
+
+These are all freely available at their respective GitHub sites. They 
+encompass communities of developers in the thousands or more. And the number
+of code developers and contributors keeps increasing.
+
+<p>
+
+<!-- ------------------- end of main content --------------- -->
+
+
+<center style="font-size:80%">
+<!-- copyright --> &copy; 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license
+</center>
+
+
+</body>
+</html>
+    
+
diff --git a/doc/Projects/2018/Project2/ipynb/ipynb-Project2-src.tar.gz b/doc/Projects/2018/Project2/ipynb/ipynb-Project2-src.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b078fdf6f5abc27cd366e4290485f19f30fe1536
GIT binary patch
literal 211
zcmb2|=3sa&wL6-D`R)0GSxklk#|qEe9kn?)>2B%c$P3Q=teUlrH+t``@XZlg`1@O|
z=qt~BrKA7fe=<B{aAuEg+UM)86YD>{$eR*WWi&C_ue8`JbnffPo91{$Uhln@8f?CG
z#lj0$J+A!q+hwsN=TU*z_KkLt^`&_d(d+ZySngM<|LMP{T<_%RP3L1jJaXQ)T439z
zp2TGPqR<_+@53*#&F=H<{Pz37BGJdyhPkgdao>A$?6-v7;-6kee_VXefD8^?{=sU%
Lk)+F@!N33jo*ie8

literal 0
HcmV?d00001

diff --git a/doc/Projects/2018/Project2/pdf/Project2.p.tex b/doc/Projects/2018/Project2/pdf/Project2.p.tex
new file mode 100644
index 000000000..6f41ac3de
--- /dev/null
+++ b/doc/Projects/2018/Project2/pdf/Project2.p.tex
@@ -0,0 +1,406 @@
+%%
+%% Automatically generated file from DocOnce source
+%% (https://github.com/hplgit/doconce/)
+%%
+%%
+% #ifdef PTEX2TEX_EXPLANATION
+%%
+%% The file follows the ptex2tex extended LaTeX format, see
+%% ptex2tex: http://code.google.com/p/ptex2tex/
+%%
+%% Run
+%%      ptex2tex myfile
+%% or
+%%      doconce ptex2tex myfile
+%%
+%% to turn myfile.p.tex into an ordinary LaTeX file myfile.tex.
+%% (The ptex2tex program: http://code.google.com/p/ptex2tex)
+%% Many preprocess options can be added to ptex2tex or doconce ptex2tex
+%%
+%%      ptex2tex -DMINTED myfile
+%%      doconce ptex2tex myfile envir=minted
+%%
+%% ptex2tex will typeset code environments according to a global or local
+%% .ptex2tex.cfg configure file. doconce ptex2tex will typeset code
+%% according to options on the command line (just type doconce ptex2tex to
+%% see examples). If doconce ptex2tex has envir=minted, it enables the
+%% minted style without needing -DMINTED.
+% #endif
+
+% #define PREAMBLE
+
+% #ifdef PREAMBLE
+%-------------------- begin preamble ----------------------
+
+\documentclass[%
+oneside,                 % oneside: electronic viewing, twoside: printing
+final,                   % draft: marks overfull hboxes, figures with paths
+10pt]{article}
+
+\listfiles               %  print all files needed to compile this document
+
+\usepackage{relsize,makeidx,color,setspace,amsmath,amsfonts,amssymb}
+\usepackage[table]{xcolor}
+\usepackage{bm,ltablex,microtype}
+
+\usepackage[pdftex]{graphicx}
+
+\usepackage[T1]{fontenc}
+%\usepackage[latin1]{inputenc}
+\usepackage{ucs}
+\usepackage[utf8x]{inputenc}
+
+\usepackage{lmodern}         % Latin Modern fonts derived from Computer Modern
+
+% Hyperlinks in PDF:
+\definecolor{linkcolor}{rgb}{0,0,0.4}
+\usepackage{hyperref}
+\hypersetup{
+    breaklinks=true,
+    colorlinks=true,
+    linkcolor=linkcolor,
+    urlcolor=linkcolor,
+    citecolor=black,
+    filecolor=black,
+    %filecolor=blue,
+    pdfmenubar=true,
+    pdftoolbar=true,
+    bookmarksdepth=3   % Uncomment (and tweak) for PDF bookmarks with more levels than the TOC
+    }
+%\hyperbaseurl{}   % hyperlinks are relative to this root
+
+\setcounter{tocdepth}{2}  % levels in table of contents
+
+% --- fancyhdr package for fancy headers ---
+\usepackage{fancyhdr}
+\fancyhf{} % sets both header and footer to nothing
+\renewcommand{\headrulewidth}{0pt}
+\fancyfoot[LE,RO]{\thepage}
+% Ensure copyright on titlepage (article style) and chapter pages (book style)
+\fancypagestyle{plain}{
+  \fancyhf{}
+  \fancyfoot[C]{{\footnotesize \copyright\ 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license}}
+%  \renewcommand{\footrulewidth}{0mm}
+  \renewcommand{\headrulewidth}{0mm}
+}
+% Ensure copyright on titlepages with \thispagestyle{empty}
+\fancypagestyle{empty}{
+  \fancyhf{}
+  \fancyfoot[C]{{\footnotesize \copyright\ 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license}}
+  \renewcommand{\footrulewidth}{0mm}
+  \renewcommand{\headrulewidth}{0mm}
+}
+
+\pagestyle{fancy}
+
+
+% prevent orhpans and widows
+\clubpenalty = 10000
+\widowpenalty = 10000
+
+% --- end of standard preamble for documents ---
+
+
+% insert custom LaTeX commands...
+
+\raggedbottom
+\makeindex
+\usepackage[totoc]{idxlayout}   % for index in the toc
+\usepackage[nottoc]{tocbibind}  % for references/bibliography in the toc
+
+%-------------------- end preamble ----------------------
+
+\begin{document}
+
+% matching end for #ifdef PREAMBLE
+% #endif
+
+\newcommand{\exercisesection}[1]{\subsection*{#1}}
+
+
+% ------------------- main content ----------------------
+
+
+
+% ----------------- title -------------------------
+
+\thispagestyle{empty}
+
+\begin{center}
+{\LARGE\bf
+\begin{spacing}{1.25}
+Project 2 on Machine Learning, deadline November 5
+\end{spacing}
+}
+\end{center}
+
+% ----------------- author(s) -------------------------
+
+\begin{center}
+{\bf \href{{http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html}}{Data Analysis and Machine Learning FYS-STK3155/FYS4155}}
+\end{center}
+
+    \begin{center}
+% List of all institutions:
+\centerline{{\small Department of Physics, University of Oslo, Norway}}
+\end{center}
+    
+% ----------------- end author(s) -------------------------
+
+% --- begin date ---
+\begin{center}
+Oct 8, 2018
+\end{center}
+% --- end date ---
+
+\vspace{1cm}
+
+
+\begin{enumerate}
+\item add about ising model
+
+\item link to where we have the data
+
+\item explain how to fit the model
+
+\item link to mehta's article
+\end{enumerate}
+
+\noindent
+\subsection{Classification and Regression, from linear and logistic regression to neural networks}
+
+The main aim of this project is to study both classification and
+regression problems, starting with the regression algortihms studied
+in project 1. We will include logistic regresion for classification
+problems and write our own multilayer perceptron code for studying
+both regression and classification problems.  The codes developed in
+project 1, including bootstrap and/or cross-validation as well as the
+computation of the mean-squared error and the R2 score function can
+also be utilized (and included in logistic regression and the neural
+network codes) in the present analysis.
+
+We will use the Ising model to generate our training data and will
+focus mainly on supervised training. We will follow closely the recent
+article of \href{{https://arxiv.org/abs/1803.08823}}{Mehta et al, arXiv
+1803.08823}. This article stands
+out as an excellent review on machine learning (ML) algorithms applied
+to typical physics problems. The added benefit is that each figure and
+model presented in \href{{https://physics.bu.edu/~pankajm/MLnotebooks.html}}{this article is accompanied by its jupyter
+notebook}. This
+means that we can start using these and compare with our own
+results. In case you wish to use their data for the Ising model, their
+data can be downloaded from the same link which lists to the jupyter
+notebooks. See also at the end of the project description for more
+information on how to install various Python packages.
+
+
+
+With the abovementioned configurations we will determine, using first
+various regression methods, the value of the coupling constant for the
+energy of the one-dimensional Ising model. Thereafter, we will use the
+two-dimensional data, but now computed at different temperatures, in
+order to classify the phase of the Ising model. Below the critical
+temperature, the system will be in a so-called ferromagnetic
+phase. Close to the critical temperature, the final magnetization
+becomes smaller and smaller in absolute value while above the critical
+temperature, the net magnetization is zero.  This classification case,
+that is the two-dimensional Ising model, will be studied using
+logistic regression and deep neural networks.  The aim is to develop
+your own logistic regression code for the classification of the phases
+(this is a binary model) and your multilayer perceptron code for the
+classification and regression case.
+
+
+Feel free to use the notebooks to benchmark your code.  If you wish to
+write your own C++ or Fortran program for say a simple neural network
+model and a logistic regression model, please feel free to do so.  You can then benchmark your results
+against the above jupyter notebooks.
+
+
+\paragraph{Part a): Producing the data.}
+You can use the Ising model data from the article of Mehta \emph{et al.},
+or generate your own data.  If you opt for using your own Ising model
+code, you need to generate $10000$ energy configurations with their
+spin orientations after the system has reached its most likely
+state. These energies and their corresponding spin orientations
+represent then your data.  We will use a fixed lattice of $L\times L =
+40 \times 40$ spins in two dimensions and $L=40$ spins in one
+dimension.  Make sure the calculations have been equilibrated. For the
+two-dimensional system, compute the configurations for three values of
+the temperature, namely $T=0.75$ (ordered phase), $T=2.3$ (near the
+critical point) and $T=4.0$ (disordered phase).  For the
+one-dimensional system it suffices to compute the various
+configurations for one temperature only, say $T=2.0$.  These are the
+data you will use to study different ML algorithms.  We generate our
+data with $J=1$.
+
+\paragraph{Part b): Estimating the coupling constant of the one-dimensional Ising model.}
+We start with the one-dimensional Ising model and use the data we have
+generated with $J=1$. Use linear regression, Lasso and Ridge
+regression as described section 6 and in Notebook 4 of \href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVI-linreg_ising.html}}{Mehta *et
+al.*}. Discuss
+the methods and how they perform in computing the coupling constant
+$J$. Give a critical analysis and discuss how to evaluate the \emph{cost
+function}. You should feel free to write your own code, see also the
+lecture notes of
+\href{{https://compphysics.github.io/MachineLearning/doc/web/course.html}}{FYS-STK4155},
+in particular te material on least square methods.  You can use
+scikit-learn to perform these analyses. See below for instruction on
+how to install scikit-learn.
+
+\paragraph{Part c): Determine the phase of the two-dimensional Ising model.}
+We switch now to binary classification methods and use logistic
+regression to define the phases of the Ising model.  Use described
+section 7 and in Notebook 6 of \href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVII-logreg_ising.html}}{Mehta *et
+al.*}. Discuss
+the methods and how they perform. Give a critical analysis and discuss
+how to evaluate the \emph{cost function}. You should feel free to write
+your own code. 
+
+
+\paragraph{Part d): Classifying the Ising model phase using neural networks.}
+We end the classification problem of the phases of the Ising model by
+employing the algorithm for so-called feed-forward deep neural
+networks (see section 9 of Mehta \emph{et al.}). The method is described in
+\href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CIX-DNN_ising_TFlow.html}}{notebook
+12}.
+
+You can use tensorflow  to perform these analyses. See below for instruction on how to install tensorflow.
+
+\subsection{Background literature}
+
+
+\begin{enumerate}
+\item The textbook of \href{{https://www.springer.com/gp/book/9780387848570}}{Trevor Hastie, Robert Tibshirani, Jerome H. Friedman, The Elements of Statistical Learning, Springer}, chapters 3 and 7 are the most relevant ones for the analysis here. 
+
+\item \href{{https://arxiv.org/abs/1803.08823}}{Mehta et al, arXiv 1803.08823}, \emph{A high-bias, low-variance introduction to Machine Learning for physicists}, ArXiv:1803.08823.
+\end{enumerate}
+
+\noindent
+If you wish to read more about the Ising model and statistical physics here are three suggestions.
+
+\begin{enumerate}
+\item \href{{http://www.worldscientific.com/worldscibooks/10.1142/5660}}{M. Plischke and B. Bergersen}, \emph{Equilibrium Statistical Physics}, World Scientific, see chapters 5 and 6.
+
+\item \href{{http://www.cambridge.org/no/academic/subjects/physics/computational-science-and-modelling/guide-monte-carlo-simulations-statistical-physics-4th-edition?format=HB}}{D. P. Landau and K. Binder}, \emph{A Guide to Monte Carlo Simulations in Statistical Physics}, Cambridge, see chapters 2,3 and 4.
+
+\item \href{{https://global.oup.com/academic/product/monte-carlo-methods-in-statistical-physics-9780198517979?cc=no&lang=en&}}{M. E. J. Newman and T. Barkema}, \emph{Monte Carlo Methods in Statistical Physics}, Oxford, see chapters 3 and 4.
+\end{enumerate}
+
+\noindent
+\subsection{Introduction to numerical projects}
+
+Here follows a brief recipe and recommendation on how to write a report for each
+project.
+
+\begin{itemize}
+  \item Give a short description of the nature of the problem and the eventual  numerical methods you have used.
+
+  \item Describe the algorithm you have used and/or developed. Here you may find it convenient to use pseudocoding. In many cases you can describe the algorithm in the program itself.
+
+  \item Include the source code of your program. Comment your program properly.
+
+  \item If possible, try to find analytic solutions, or known limits in order to test your program when developing the code.
+
+  \item Include your results either in figure form or in a table. Remember to        label your results. All tables and figures should have relevant captions        and labels on the axes.
+
+  \item Try to evaluate the reliabilty and numerical stability/precision of your results. If possible, include a qualitative and/or quantitative discussion of the numerical stability, eventual loss of precision etc.
+
+  \item Try to give an interpretation of you results in your answers to  the problems.
+
+  \item Critique: if possible include your comments and reflections about the  exercise, whether you felt you learnt something, ideas for improvements and  other thoughts you've made when solving the exercise. We wish to keep this course at the interactive level and your comments can help us improve it.
+
+  \item Try to establish a practice where you log your work at the  computerlab. You may find such a logbook very handy at later stages in your work, especially when you don't properly remember  what a previous test version  of your program did. Here you could also record  the time spent on solving the exercise, various algorithms you may have tested or other topics which you feel worthy of mentioning.
+\end{itemize}
+
+\noindent
+\subsection{Format for electronic delivery of report and programs}
+
+The preferred format for the report is a PDF file. You can also use DOC or postscript formats or as an ipython notebook file.  As programming language we prefer that you choose between C/C++, Fortran2008 or Python. The following prescription should be followed when preparing the report:
+
+\begin{itemize}
+  \item Use Devilry to hand in your projects, log in  at  \href{{http://devilry.ifi.uio.no}}{\nolinkurl{http://devilry.ifi.uio.no}} with your normal UiO username and password and choose either 'fysstk3155' or 'fysstk4155'. There you can load up the files within the deadline.
+
+  \item Upload \textbf{only} the report file!  For the source code file(s) you have developed please provide us with your link to your github domain.  The report file should include all of your discussions and a list of the codes you have developed.  Do not include library files which are available at the course homepage, unless you have made specific changes to them.
+
+  \item In your git repository, please include a folder which contains selected results. These can be in the form of output from your code for a selected set of runs and input parameters.
+
+  \item In this and all later projects, you should include tests (for example unit tests) of your code(s).
+
+  \item Comments  from us on your projects, approval or not, corrections to be made  etc can be found under your Devilry domain and are only visible to you and the teachers of the course.
+\end{itemize}
+
+\noindent
+Finally, 
+we encourage you to collaborate. Optimal working groups consist of 
+2-3 students. You can then hand in a common report. 
+
+
+
+\subsection{Software and needed installations}
+
+If you have Python installed (we recommend Python3) and you feel pretty familiar with installing different packages, 
+we recommend that you install the following Python packages via \textbf{pip} as
+\begin{enumerate}
+\item pip install numpy scipy matplotlib ipython scikit-learn tensorflow sympy pandas pillow
+\end{enumerate}
+
+\noindent
+For Python3, replace \textbf{pip} with \textbf{pip3}.
+
+See below for a discussion of \textbf{tensorflow} and \textbf{scikit-learn}. 
+
+For OSX users we recommend also, after having installed Xcode, to install \textbf{brew}. Brew allows 
+for a seamless installation of additional software via for example
+\begin{enumerate}
+\item brew install python3
+\end{enumerate}
+
+\noindent
+For Linux users, with its variety of distributions like for example the widely popular Ubuntu distribution
+you can use \textbf{pip} as well and simply install Python as 
+\begin{enumerate}
+\item sudo apt-get install python3  (or python for python2.7)
+\end{enumerate}
+
+\noindent
+etc etc. 
+
+If you don't want to install various Python packages with their dependencies separately, we recommend two widely used distrubutions which set up  all relevant dependencies for Python, namely
+\begin{enumerate}
+\item \href{{https://docs.anaconda.com/}}{Anaconda} Anaconda is an open source distribution of the Python and R programming languages for large-scale data processing, predictive analytics, and scientific computing, that aims to simplify package management and deployment. Package versions are managed by the package management system \textbf{conda}
+
+\item \href{{https://www.enthought.com/product/canopy/}}{Enthought canopy}  is a Python distribution for scientific and analytic computing distribution and analysis environment, available for free and under a commercial license.
+\end{enumerate}
+
+\noindent
+Popular software packages written in Python for ML are
+
+\begin{itemize}
+\item \href{{http://scikit-learn.org/stable/}}{Scikit-learn}, 
+
+\item \href{{https://www.tensorflow.org/}}{Tensorflow},
+
+\item \href{{http://pytorch.org/}}{PyTorch} and 
+
+\item \href{{https://keras.io/}}{Keras}.
+\end{itemize}
+
+\noindent
+These are all freely available at their respective GitHub sites. They 
+encompass communities of developers in the thousands or more. And the number
+of code developers and contributors keeps increasing.
+
+
+
+
+
+
+
+
+% ------------------- end of main content ---------------
+
+% #ifdef PREAMBLE
+\end{document}
+% #endif
+
diff --git a/doc/Projects/2018/Project2/pdf/Project2.pdf b/doc/Projects/2018/Project2/pdf/Project2.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..95bc1a5d5375fa4c70bfdd1427ea759dcb6b2a16
GIT binary patch
literal 210950
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
Ux)GRxOe`F12w%U7DTpKd7k;GwFaQ7m

literal 0
HcmV?d00001

diff --git a/doc/Projects/2018/Project2/pdf/Project2.tex b/doc/Projects/2018/Project2/pdf/Project2.tex
new file mode 100644
index 000000000..1de756aa3
--- /dev/null
+++ b/doc/Projects/2018/Project2/pdf/Project2.tex
@@ -0,0 +1,378 @@
+%%
+%% Automatically generated file from DocOnce source
+%% (https://github.com/hplgit/doconce/)
+%%
+%%
+
+
+%-------------------- begin preamble ----------------------
+
+\documentclass[%
+oneside,                 % oneside: electronic viewing, twoside: printing
+final,                   % draft: marks overfull hboxes, figures with paths
+10pt]{article}
+
+\listfiles               %  print all files needed to compile this document
+
+\usepackage{relsize,makeidx,color,setspace,amsmath,amsfonts,amssymb}
+\usepackage[table]{xcolor}
+\usepackage{bm,ltablex,microtype}
+
+\usepackage[pdftex]{graphicx}
+
+\usepackage[T1]{fontenc}
+%\usepackage[latin1]{inputenc}
+\usepackage{ucs}
+\usepackage[utf8x]{inputenc}
+
+\usepackage{lmodern}         % Latin Modern fonts derived from Computer Modern
+
+% Hyperlinks in PDF:
+\definecolor{linkcolor}{rgb}{0,0,0.4}
+\usepackage{hyperref}
+\hypersetup{
+    breaklinks=true,
+    colorlinks=true,
+    linkcolor=linkcolor,
+    urlcolor=linkcolor,
+    citecolor=black,
+    filecolor=black,
+    %filecolor=blue,
+    pdfmenubar=true,
+    pdftoolbar=true,
+    bookmarksdepth=3   % Uncomment (and tweak) for PDF bookmarks with more levels than the TOC
+    }
+%\hyperbaseurl{}   % hyperlinks are relative to this root
+
+\setcounter{tocdepth}{2}  % levels in table of contents
+
+% --- fancyhdr package for fancy headers ---
+\usepackage{fancyhdr}
+\fancyhf{} % sets both header and footer to nothing
+\renewcommand{\headrulewidth}{0pt}
+\fancyfoot[LE,RO]{\thepage}
+% Ensure copyright on titlepage (article style) and chapter pages (book style)
+\fancypagestyle{plain}{
+  \fancyhf{}
+  \fancyfoot[C]{{\footnotesize \copyright\ 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license}}
+%  \renewcommand{\footrulewidth}{0mm}
+  \renewcommand{\headrulewidth}{0mm}
+}
+% Ensure copyright on titlepages with \thispagestyle{empty}
+\fancypagestyle{empty}{
+  \fancyhf{}
+  \fancyfoot[C]{{\footnotesize \copyright\ 1999-2018, "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html". Released under CC Attribution-NonCommercial 4.0 license}}
+  \renewcommand{\footrulewidth}{0mm}
+  \renewcommand{\headrulewidth}{0mm}
+}
+
+\pagestyle{fancy}
+
+
+% prevent orhpans and widows
+\clubpenalty = 10000
+\widowpenalty = 10000
+
+% --- end of standard preamble for documents ---
+
+
+% insert custom LaTeX commands...
+
+\raggedbottom
+\makeindex
+\usepackage[totoc]{idxlayout}   % for index in the toc
+\usepackage[nottoc]{tocbibind}  % for references/bibliography in the toc
+
+%-------------------- end preamble ----------------------
+
+\begin{document}
+
+% matching end for #ifdef PREAMBLE
+
+\newcommand{\exercisesection}[1]{\subsection*{#1}}
+
+
+% ------------------- main content ----------------------
+
+
+
+% ----------------- title -------------------------
+
+\thispagestyle{empty}
+
+\begin{center}
+{\LARGE\bf
+\begin{spacing}{1.25}
+Project 2 on Machine Learning, deadline November 5
+\end{spacing}
+}
+\end{center}
+
+% ----------------- author(s) -------------------------
+
+\begin{center}
+{\bf \href{{http://www.uio.no/studier/emner/matnat/fys/FYS3155/index-eng.html}}{Data Analysis and Machine Learning FYS-STK3155/FYS4155}}
+\end{center}
+
+    \begin{center}
+% List of all institutions:
+\centerline{{\small Department of Physics, University of Oslo, Norway}}
+\end{center}
+    
+% ----------------- end author(s) -------------------------
+
+% --- begin date ---
+\begin{center}
+Oct 8, 2018
+\end{center}
+% --- end date ---
+
+\vspace{1cm}
+
+
+\begin{enumerate}
+\item add about ising model
+
+\item link to where we have the data
+
+\item explain how to fit the model
+
+\item link to mehta's article
+\end{enumerate}
+
+\noindent
+\subsection*{Classification and Regression, from linear and logistic regression to neural networks}
+
+The main aim of this project is to study both classification and
+regression problems, starting with the regression algortihms studied
+in project 1. We will include logistic regresion for classification
+problems and write our own multilayer perceptron code for studying
+both regression and classification problems.  The codes developed in
+project 1, including bootstrap and/or cross-validation as well as the
+computation of the mean-squared error and the R2 score function can
+also be utilized (and included in logistic regression and the neural
+network codes) in the present analysis.
+
+We will use the Ising model to generate our training data and will
+focus mainly on supervised training. We will follow closely the recent
+article of \href{{https://arxiv.org/abs/1803.08823}}{Mehta et al, arXiv
+1803.08823}. This article stands
+out as an excellent review on machine learning (ML) algorithms applied
+to typical physics problems. The added benefit is that each figure and
+model presented in \href{{https://physics.bu.edu/~pankajm/MLnotebooks.html}}{this article is accompanied by its jupyter
+notebook}. This
+means that we can start using these and compare with our own
+results. In case you wish to use their data for the Ising model, their
+data can be downloaded from the same link which lists to the jupyter
+notebooks. See also at the end of the project description for more
+information on how to install various Python packages.
+
+
+
+With the abovementioned configurations we will determine, using first
+various regression methods, the value of the coupling constant for the
+energy of the one-dimensional Ising model. Thereafter, we will use the
+two-dimensional data, but now computed at different temperatures, in
+order to classify the phase of the Ising model. Below the critical
+temperature, the system will be in a so-called ferromagnetic
+phase. Close to the critical temperature, the final magnetization
+becomes smaller and smaller in absolute value while above the critical
+temperature, the net magnetization is zero.  This classification case,
+that is the two-dimensional Ising model, will be studied using
+logistic regression and deep neural networks.  The aim is to develop
+your own logistic regression code for the classification of the phases
+(this is a binary model) and your multilayer perceptron code for the
+classification and regression case.
+
+
+Feel free to use the notebooks to benchmark your code.  If you wish to
+write your own C++ or Fortran program for say a simple neural network
+model and a logistic regression model, please feel free to do so.  You can then benchmark your results
+against the above jupyter notebooks.
+
+
+\paragraph{Part a): Producing the data.}
+You can use the Ising model data from the article of Mehta \emph{et al.},
+or generate your own data.  If you opt for using your own Ising model
+code, you need to generate $10000$ energy configurations with their
+spin orientations after the system has reached its most likely
+state. These energies and their corresponding spin orientations
+represent then your data.  We will use a fixed lattice of $L\times L =
+40 \times 40$ spins in two dimensions and $L=40$ spins in one
+dimension.  Make sure the calculations have been equilibrated. For the
+two-dimensional system, compute the configurations for three values of
+the temperature, namely $T=0.75$ (ordered phase), $T=2.3$ (near the
+critical point) and $T=4.0$ (disordered phase).  For the
+one-dimensional system it suffices to compute the various
+configurations for one temperature only, say $T=2.0$.  These are the
+data you will use to study different ML algorithms.  We generate our
+data with $J=1$.
+
+\paragraph{Part b): Estimating the coupling constant of the one-dimensional Ising model.}
+We start with the one-dimensional Ising model and use the data we have
+generated with $J=1$. Use linear regression, Lasso and Ridge
+regression as described section 6 and in Notebook 4 of \href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVI-linreg_ising.html}}{Mehta *et
+al.*}. Discuss
+the methods and how they perform in computing the coupling constant
+$J$. Give a critical analysis and discuss how to evaluate the \emph{cost
+function}. You should feel free to write your own code, see also the
+lecture notes of
+\href{{https://compphysics.github.io/MachineLearning/doc/web/course.html}}{FYS-STK4155},
+in particular te material on least square methods.  You can use
+scikit-learn to perform these analyses. See below for instruction on
+how to install scikit-learn.
+
+\paragraph{Part c): Determine the phase of the two-dimensional Ising model.}
+We switch now to binary classification methods and use logistic
+regression to define the phases of the Ising model.  Use described
+section 7 and in Notebook 6 of \href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CVII-logreg_ising.html}}{Mehta *et
+al.*}. Discuss
+the methods and how they perform. Give a critical analysis and discuss
+how to evaluate the \emph{cost function}. You should feel free to write
+your own code. 
+
+
+\paragraph{Part d): Classifying the Ising model phase using neural networks.}
+We end the classification problem of the phases of the Ising model by
+employing the algorithm for so-called feed-forward deep neural
+networks (see section 9 of Mehta \emph{et al.}). The method is described in
+\href{{https://physics.bu.edu/~pankajm/ML-Notebooks/HTML/NB_CIX-DNN_ising_TFlow.html}}{notebook
+12}.
+
+You can use tensorflow  to perform these analyses. See below for instruction on how to install tensorflow.
+
+\subsection*{Background literature}
+
+
+\begin{enumerate}
+\item The textbook of \href{{https://www.springer.com/gp/book/9780387848570}}{Trevor Hastie, Robert Tibshirani, Jerome H. Friedman, The Elements of Statistical Learning, Springer}, chapters 3 and 7 are the most relevant ones for the analysis here. 
+
+\item \href{{https://arxiv.org/abs/1803.08823}}{Mehta et al, arXiv 1803.08823}, \emph{A high-bias, low-variance introduction to Machine Learning for physicists}, ArXiv:1803.08823.
+\end{enumerate}
+
+\noindent
+If you wish to read more about the Ising model and statistical physics here are three suggestions.
+
+\begin{enumerate}
+\item \href{{http://www.worldscientific.com/worldscibooks/10.1142/5660}}{M. Plischke and B. Bergersen}, \emph{Equilibrium Statistical Physics}, World Scientific, see chapters 5 and 6.
+
+\item \href{{http://www.cambridge.org/no/academic/subjects/physics/computational-science-and-modelling/guide-monte-carlo-simulations-statistical-physics-4th-edition?format=HB}}{D. P. Landau and K. Binder}, \emph{A Guide to Monte Carlo Simulations in Statistical Physics}, Cambridge, see chapters 2,3 and 4.
+
+\item \href{{https://global.oup.com/academic/product/monte-carlo-methods-in-statistical-physics-9780198517979?cc=no&lang=en&}}{M. E. J. Newman and T. Barkema}, \emph{Monte Carlo Methods in Statistical Physics}, Oxford, see chapters 3 and 4.
+\end{enumerate}
+
+\noindent
+\subsection*{Introduction to numerical projects}
+
+Here follows a brief recipe and recommendation on how to write a report for each
+project.
+
+\begin{itemize}
+  \item Give a short description of the nature of the problem and the eventual  numerical methods you have used.
+
+  \item Describe the algorithm you have used and/or developed. Here you may find it convenient to use pseudocoding. In many cases you can describe the algorithm in the program itself.
+
+  \item Include the source code of your program. Comment your program properly.
+
+  \item If possible, try to find analytic solutions, or known limits in order to test your program when developing the code.
+
+  \item Include your results either in figure form or in a table. Remember to        label your results. All tables and figures should have relevant captions        and labels on the axes.
+
+  \item Try to evaluate the reliabilty and numerical stability/precision of your results. If possible, include a qualitative and/or quantitative discussion of the numerical stability, eventual loss of precision etc.
+
+  \item Try to give an interpretation of you results in your answers to  the problems.
+
+  \item Critique: if possible include your comments and reflections about the  exercise, whether you felt you learnt something, ideas for improvements and  other thoughts you've made when solving the exercise. We wish to keep this course at the interactive level and your comments can help us improve it.
+
+  \item Try to establish a practice where you log your work at the  computerlab. You may find such a logbook very handy at later stages in your work, especially when you don't properly remember  what a previous test version  of your program did. Here you could also record  the time spent on solving the exercise, various algorithms you may have tested or other topics which you feel worthy of mentioning.
+\end{itemize}
+
+\noindent
+\subsection*{Format for electronic delivery of report and programs}
+
+The preferred format for the report is a PDF file. You can also use DOC or postscript formats or as an ipython notebook file.  As programming language we prefer that you choose between C/C++, Fortran2008 or Python. The following prescription should be followed when preparing the report:
+
+\begin{itemize}
+  \item Use Devilry to hand in your projects, log in  at  \href{{http://devilry.ifi.uio.no}}{\nolinkurl{http://devilry.ifi.uio.no}} with your normal UiO username and password and choose either 'fysstk3155' or 'fysstk4155'. There you can load up the files within the deadline.
+
+  \item Upload \textbf{only} the report file!  For the source code file(s) you have developed please provide us with your link to your github domain.  The report file should include all of your discussions and a list of the codes you have developed.  Do not include library files which are available at the course homepage, unless you have made specific changes to them.
+
+  \item In your git repository, please include a folder which contains selected results. These can be in the form of output from your code for a selected set of runs and input parameters.
+
+  \item In this and all later projects, you should include tests (for example unit tests) of your code(s).
+
+  \item Comments  from us on your projects, approval or not, corrections to be made  etc can be found under your Devilry domain and are only visible to you and the teachers of the course.
+\end{itemize}
+
+\noindent
+Finally, 
+we encourage you to collaborate. Optimal working groups consist of 
+2-3 students. You can then hand in a common report. 
+
+
+
+\subsection*{Software and needed installations}
+
+If you have Python installed (we recommend Python3) and you feel pretty familiar with installing different packages, 
+we recommend that you install the following Python packages via \textbf{pip} as
+\begin{enumerate}
+\item pip install numpy scipy matplotlib ipython scikit-learn tensorflow sympy pandas pillow
+\end{enumerate}
+
+\noindent
+For Python3, replace \textbf{pip} with \textbf{pip3}.
+
+See below for a discussion of \textbf{tensorflow} and \textbf{scikit-learn}. 
+
+For OSX users we recommend also, after having installed Xcode, to install \textbf{brew}. Brew allows 
+for a seamless installation of additional software via for example
+\begin{enumerate}
+\item brew install python3
+\end{enumerate}
+
+\noindent
+For Linux users, with its variety of distributions like for example the widely popular Ubuntu distribution
+you can use \textbf{pip} as well and simply install Python as 
+\begin{enumerate}
+\item sudo apt-get install python3  (or python for python2.7)
+\end{enumerate}
+
+\noindent
+etc etc. 
+
+If you don't want to install various Python packages with their dependencies separately, we recommend two widely used distrubutions which set up  all relevant dependencies for Python, namely
+\begin{enumerate}
+\item \href{{https://docs.anaconda.com/}}{Anaconda} Anaconda is an open source distribution of the Python and R programming languages for large-scale data processing, predictive analytics, and scientific computing, that aims to simplify package management and deployment. Package versions are managed by the package management system \textbf{conda}
+
+\item \href{{https://www.enthought.com/product/canopy/}}{Enthought canopy}  is a Python distribution for scientific and analytic computing distribution and analysis environment, available for free and under a commercial license.
+\end{enumerate}
+
+\noindent
+Popular software packages written in Python for ML are
+
+\begin{itemize}
+\item \href{{http://scikit-learn.org/stable/}}{Scikit-learn}, 
+
+\item \href{{https://www.tensorflow.org/}}{Tensorflow},
+
+\item \href{{http://pytorch.org/}}{PyTorch} and 
+
+\item \href{{https://keras.io/}}{Keras}.
+\end{itemize}
+
+\noindent
+These are all freely available at their respective GitHub sites. They 
+encompass communities of developers in the thousands or more. And the number
+of code developers and contributors keeps increasing.
+
+
+
+
+
+
+
+
+% ------------------- end of main content ---------------
+
+\end{document}
+
diff --git a/doc/src/Projects/2018/Project2/Project2.do.txt b/doc/src/Projects/2018/Project2/Project2.do.txt
index 27ce7ff3c..4a62f18cb 100644
--- a/doc/src/Projects/2018/Project2/Project2.do.txt
+++ b/doc/src/Projects/2018/Project2/Project2.do.txt
@@ -3,6 +3,11 @@ AUTHOR: "Data Analysis and Machine Learning FYS-STK3155/FYS4155":"http://www.uio
 DATE: today
 
 
+o add about ising model
+o link to where we have the data
+o explain how to fit the model
+o link to mehta's article
+
 ===== Classification and Regression, from linear and logistic regression to neural networks  =====
 
 The main aim of this project is to study both classification and