Math_Part1_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2017, 2, 23)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "author = \"kyubyong. https://github.com/Kyubyong/tensorflow-exercises\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.0.0'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.12.0'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "NOTE on notation\n",
    "* _x, _y, _z, ...: NumPy 0-d or 1-d arrays\n",
    "* _X, _Y, _Z, ...: NumPy 2-d or higer dimensional arrays\n",
    "* x, y, z, ...: 0-d or 1-d tensors\n",
    "* X, Y, Z, ...: 2-d or higher dimensional tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Add x and y element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 3])\n",
    "_y = np.array([-1, -2, -3])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "out1 = tf.add(x, y)\n",
    "out2 = x + y \n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval()) # tf.add is the same as the `+` operator.\n",
    "\n",
    "_out = np.add(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.add == np.add"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Subtract y from x element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([3, 4, 5])\n",
    "_y = np.array(3)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "out1 = tf.subtract(x, y)\n",
    "out2 = x - y \n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval()) # tf.subtract is the same as the `-` operator.\n",
    "\n",
    "_out = np.subtract(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.subtract == np.subtract\n",
    "# `add`, `subtract`, `multiply`, `div`, and `mod` support broadcasting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Multiply x by y element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3  0 -5]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([3, 4, 5])\n",
    "_y = np.array([1, 0, -1])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "out1 = tf.multiply(x, y)\n",
    "out2 = x * y \n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval()) # tf.multiply is the same as the `*` operator.\n",
    "\n",
    "_out = np.multiply(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.multiply == np.multiply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Multiply x by 5 element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5 10 15]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 3])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "out1 = tf.scalar_mul(5, x)\n",
    "out2 = x * 5\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = _x * 5\n",
    "assert np.array_equal(out1.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Predict the result of this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "[5 6 6] int32\n",
      "[ 5.          6.66666667  6.        ] float64\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([10, 20, 30], np.int32)\n",
    "_y = np.array([2, 3, 5], np.int32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "out1 = tf.div(x, y)\n",
    "out2 = tf.truediv(x, y)\n",
    "print(np.array_equal(out1.eval(), out2.eval()))\n",
    "\n",
    "print(out1.eval(), out1.eval().dtype) # tf.div() returns the same results as input tensors. \n",
    "print(out2.eval(), out2.eval().dtype)# tf.truediv() always returns floating point results.\n",
    "\n",
    "_out1 = _x // _y\n",
    "assert np.array_equal(out1.eval(), _out1)\n",
    "\n",
    "_out2 = _x / _y\n",
    "assert np.array_equal(out2.eval(), _out2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Get the remainder of x / y element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 2]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([10, 20, 30], np.int32)\n",
    "_y = np.array([2, 3, 7], np.int32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.mod(x, y)\n",
    "out2 = x % y\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())# tf.mod() is the same as the `%` operator.\n",
    "\n",
    "_out = _x % _y\n",
    "assert np.array_equal(out1.eval(), _out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Compute the pairwise cross product of x and y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3  6 -3]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 3], np.int32)\n",
    "_y = np.array([4, 5, 6], np.int32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.cross(x, y)\n",
    "print(out1.eval())\n",
    "\n",
    "_out = np.cross(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.cross == np.cross"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Math Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Add x, y, and z element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9 12 15]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 3], np.int32)\n",
    "_y = np.array([4, 5, 6], np.int32)\n",
    "_z = np.array([7, 8, 9], np.int32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "z = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.add_n([x, y, z])\n",
    "out2 = x + y + z\n",
    "print(out1.eval())\n",
    "\n",
    "assert np.array_equal(out1.eval(), out2.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Compute the absolute value of X element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [3 3]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, -1], [3, -3]])\n",
    "X = tf.convert_to_tensor(_X)\n",
    "\n",
    "out = tf.abs(X)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.abs(_X)\n",
    "assert np.array_equal(out.eval(), _out) # tf.abs == np.abs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Compute numerical negative value of x, elemet-wise.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [3 3]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, -1])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.negative(x)\n",
    "out2 = -x\n",
    "print(out.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.negative(_x)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.negative == np.negative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Compute an element-wise indication of the sign of x, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  1  0 -1 -1]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 3, 0, -1, -3])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.sign(x)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.sign(_x)\n",
    "assert np.array_equal(out.eval(), _out) # tf.sign == np.sign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Compute the reciprocal of x, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.   0.5  5. ]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 2/10])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.reciprocal(x)\n",
    "out2 = 1/x\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.reciprocal(_x)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.reciprocal == np.reciprocal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Compute the square of x, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 1]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, -1])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.square(x)\n",
    "out2 = x * x\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.square(_x)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.square == np.square"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Predict the results of this, paying attention to the difference among the family functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.  2.  2.  3. -2. -2. -3.]\n",
      "[ 2.  1.  2.  2. -3. -3. -3.]\n",
      "[ 3.  2.  3.  3. -2. -2. -2.]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([2.1, 1.5, 2.5, 2.9, -2.1, -2.5, -2.9])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.round(x)\n",
    "out2 = tf.floor(x)\n",
    "out3 = tf.ceil(x)\n",
    "print(out1.eval())\n",
    "print(out2.eval())\n",
    "print(out3.eval())\n",
    "\n",
    "_out1 = np.around(_x)\n",
    "_out2 = np.floor(_x)\n",
    "_out3 = np.ceil(_x)\n",
    "assert np.array_equal(out1.eval(), _out1) # tf.round == np.around\n",
    "assert np.array_equal(out2.eval(), _out2) # tf.floor == np.floor\n",
    "assert np.array_equal(out3.eval(), _out3) # tf.ceil == np.ceil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Compute square root of x element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  2.  3.]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 4, 9], dtype=np.float32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.sqrt(x)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.sqrt(_x)\n",
    "assert np.array_equal(out.eval(), _out) # tf.sqrt ≈ np.sqrt\n",
    "# Note that in TensorFlow, the input tensor must be\n",
    "# a float, whereas in Numpy, an integer is okay."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Q16. Compute the reciprocal of square root of x element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.          0.5         0.33333333]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1., 4., 9.])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.rsqrt(x)\n",
    "out2 = tf.reciprocal(tf.sqrt(x))\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Compute $x^y$, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  4]\n",
      " [ 3 16]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[1, 2], [3, 4]])\n",
    "_y = np.array([[1, 2], [1, 2]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out = tf.pow(x, y)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.power(_x, _y)\n",
    "assert np.array_equal(out.eval(), _out) # tf.pow == np.power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Compute $e^x$, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  2.71828175   7.38905621  20.08553696]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1., 2., 3.], np.float32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.exp(x)\n",
    "out2 = tf.pow(np.e, x) #np.e = 2.718281828459045\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.exp(_x)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.exp == np.exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q18. Compute natural logarithm of x element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  2.]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, np.e, np.e**2])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.log(x)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.log(_x)\n",
    "assert np.array_equal(out.eval(), _out) # tf.log == np.log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q19. Compute the max of x and y element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 5 4]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([2, 3, 4])\n",
    "_y = np.array([1, 5, 2])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.maximum(x, y)\n",
    "out2 = tf.where(x > y, x, y)\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.maximum(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.maximum == np.maximum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q20. Compute the min of x and y element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 2]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([2, 3, 4])\n",
    "_y = np.array([1, 5, 2])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.minimum(x, y)\n",
    "out2 = tf.where(x < y, x, y)\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n",
    "\n",
    "_out = np.minimum(_x, _y)\n",
    "assert np.array_equal(out1.eval(), _out) # tf.minimum == np.minimum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q21. Compuete the sine, cosine, and tangent of x, element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -1.22464680e-16   1.22464680e-16   1.00000000e+00]\n",
      "[ -1.00000000e+00  -1.00000000e+00   6.12323400e-17]\n",
      "[  1.22464680e-16  -1.22464680e-16   1.63312394e+16]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([-np.pi, np.pi, np.pi/2])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.sin(x)\n",
    "out2 = tf.cos(x)\n",
    "out3 = tf.tan(x)\n",
    "print(out1.eval())\n",
    "print(out2.eval())\n",
    "print(out3.eval())\n",
    "\n",
    "_out1 = np.sin(_x)\n",
    "_out2 = np.cos(_x)\n",
    "_out3 = np.tan(_x)\n",
    "\n",
    "assert np.allclose(out1.eval(), _out1) # tf.sin == np.sin\n",
    "assert np.allclose(out2.eval(), _out2) # tf.cos == np.cos\n",
    "assert np.allclose(out3.eval(), _out3) # tf.tan == np.tan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q22. Compute (x - y)(x - y) element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 9]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([2, 3, 4])\n",
    "_y = np.array([1, 5, 1])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out1 = tf.squared_difference(x, y)\n",
    "out2 = tf.square(tf.subtract(x, y))\n",
    "print(out1.eval())\n",
    "assert np.array_equal(out1.eval(), out2.eval())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}