teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/notebooks/sqlalchemy/Teradata Vantage Arithmetic Functions Using SQLAlchemy.ipynb

@@ -0,0 +1,1993 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Disclaimer\n",
+    "Please note, the Vantage Functions via SQLAlchemy feature is a preview/beta code release with limited functionality (the “Code”). As such, you acknowledge that the Code is experimental in nature and that the Code is provided “AS IS” and may not be functional on any machine or in any environment. TERADATA DISCLAIMS ALL WARRANTIES RELATING TO THE CODE, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES AGAINST INFRINGEMENT OF THIRD-PARTY RIGHTS, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n",
+    "\n",
+    "TERADATA SHALL NOT BE RESPONSIBLE OR LIABLE WITH RESPECT TO ANY SUBJECT MATTER OF THE CODE UNDER ANY CONTRACT, NEGLIGENCE, STRICT LIABILITY OR OTHER THEORY \n",
+    "    (A) FOR LOSS OR INACCURACY OF DATA OR COST OF PROCUREMENT OF SUBSTITUTE GOODS, SERVICES OR TECHNOLOGY, OR \n",
+    "    (B) FOR ANY INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO LOSS OF REVENUES AND LOSS OF PROFITS. TERADATA SHALL NOT BE RESPONSIBLE FOR ANY MATTER BEYOND ITS REASONABLE CONTROL.\n",
+    "\n",
+    "Notwithstanding anything to the contrary: \n",
+    "    (a) Teradata will have no obligation of any kind with respect to any Code-related comments, suggestions, design changes or improvements that you elect to provide to Teradata in either verbal or written form (collectively, “Feedback”), and \n",
+    "    (b) Teradata and its affiliates are hereby free to use any ideas, concepts, know-how or techniques, in whole or in part, contained in Feedback: \n",
+    "        (i) for any purpose whatsoever, including developing, manufacturing, and/or marketing products and/or services incorporating Feedback in whole or in part, and \n",
+    "        (ii) without any restrictions or limitations, including requiring the payment of any license fees, royalties, or other consideration. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In this notebook we shall cover examples for following Arithmetic Functions:\n",
+    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/c2fX4dzxCcDJFKqXbyQtTA\n",
+    "    # 1. abs\n",
+    "    # 2. case_n\n",
+    "    # 3. ceil/ceiling\n",
+    "    # 4. degrees\n",
+    "    # 5. radians\n",
+    "    # 6. exp\n",
+    "    # 7. floor\n",
+    "    # 8. ln\n",
+    "    # 9. log\n",
+    "    # 10. mod\n",
+    "    # 11. nullifzero \n",
+    "    # 12. power\n",
+    "    # 13. random\n",
+    "    # 14. range_n\n",
+    "    # 15. round\n",
+    "    # 16. sign\n",
+    "    # 17. sqrt\n",
+    "    # 18. trunc\n",
+    "    # 19. width_bucket\n",
+    "    # Hyperbolic Functions:\n",
+    "        # 1. cosh\n",
+    "        # 2. acosh\n",
+    "        # 3. sinh\n",
+    "        # 4. asinh\n",
+    "        # 5. tanh\n",
+    "        # 6. atanh\n",
+    "    # Trigonometric Functions:\n",
+    "        # 1. sin\n",
+    "        # 2. asin\n",
+    "        # 3. cos\n",
+    "        # 4. acos\n",
+    "        # 5. tan\n",
+    "        # 6. atan\n",
+    "        # 7. atan2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hostname: ········\n",
+      "Username: ········\n",
+      "Password: ········\n",
+      "WARNING: Skipped loading table admissions_train since it already exists in the database.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the connection to the Vantage using create_context()\n",
+    "from teradataml import *\n",
+    "import getpass\n",
+    "td_context = create_context(host=getpass.getpass(\"Hostname: \"), username=getpass.getpass(\"Username: \"), password=getpass.getpass(\"Password: \"))\n",
+    "# Load the example dataset.\n",
+    "load_example_data(\"GLM\", [\"admissions_train\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "   masters   gpa     stats programming  admitted\n",
+       "id                                              \n",
+       "5       no  3.44    Novice      Novice         0\n",
+       "34     yes  3.85  Advanced    Beginner         0\n",
+       "13      no  4.00  Advanced      Novice         1\n",
+       "40     yes  3.95    Novice    Beginner         0\n",
+       "22     yes  3.46    Novice    Beginner         0\n",
+       "19     yes  1.98  Advanced    Advanced         0\n",
+       "36      no  3.00  Advanced      Novice         0\n",
+       "15     yes  4.00  Advanced    Advanced         1\n",
+       "7      yes  2.33    Novice      Novice         1\n",
+       "17      no  3.83  Advanced    Advanced         1"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create the DataFrame on 'admissions_train' table\n",
+    "admissions_train = DataFrame(\"admissions_train\")\n",
+    "admissions_train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_variables(df, columns):\n",
+    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
+    "    print(\"\\n\")\n",
+    "    print(\" ************************* DataFrame ********************* \")\n",
+    "    print(df)\n",
+    "    print(\"\\n\\n\")\n",
+    "    print(\" ************************* DataFrame.dtypes ********************* \")\n",
+    "    print(df.dtypes)\n",
+    "    print(\"\\n\\n\")\n",
+    "    if isinstance(columns, str):\n",
+    "        columns = [columns]\n",
+    "    for col in columns:\n",
+    "        coltype = df.__getattr__(col).type\n",
+    "        if isinstance(coltype, sqlalchemy.sql.sqltypes.NullType):\n",
+    "            coltype = \"NullType\"\n",
+    "        print(\" '{}' Column Type: {}\".format(col, coltype))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using Arithmatic Functions in Teradata Vantage with the help SQLAlchemny"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import func from SQLAlchemy to use the same for executing arithmetic functions\n",
+    "from sqlalchemy import func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before we move on with examples, one should read below just to understand how teradataml DataFrame and \n",
+    "# it's columns are used to create a SQLAlchemy ClauseElement/Expression.\n",
+    "\n",
+    "# Often in below examples one would see something like this: 'admissions_train.admitted.expression'\n",
+    "# Here in the above expression,\n",
+    "#    'admissions_train' is 'teradataml DataFrame'\n",
+    "#    'admitted' is 'column name' in teradataml DataFrame 'admissions_train'\n",
+    "#    Thus, \n",
+    "#        'admissions_train.admitted' together forms a ColumnExpression.\n",
+    "#    expression allows us to use teradata ColumnExpression to be treated as SQLAlchemy Expression.\n",
+    "#    Thus,\n",
+    "#        'admissions_train.admitted.expression' gives us an expression that can be used with SQLAlchemy clauseElements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ABS function - Compute the absolute value of an argument."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function computes the absolute value of an argument.\n",
+    "# Syntax:\n",
+    "#         ABS(column_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs_func_ = func.abs(admissions_train.gpa.expression)\n",
+    "type(abs_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, abs(admitted) AS abd_addmitted_, abs(gpa) AS abs_gpa_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  abd_addmitted_  abs_gpa_\n",
+      "id                                                                        \n",
+      "15     yes  4.00  Advanced    Advanced         1               1      4.00\n",
+      "7      yes  2.33    Novice      Novice         1               1      2.33\n",
+      "22     yes  3.46    Novice    Beginner         0               0      3.46\n",
+      "17      no  3.83  Advanced    Advanced         1               1      3.83\n",
+      "13      no  4.00  Advanced      Novice         1               1      4.00\n",
+      "38     yes  2.65  Advanced    Beginner         1               1      2.65\n",
+      "26     yes  3.57  Advanced    Advanced         1               1      3.57\n",
+      "5       no  3.44    Novice      Novice         0               0      3.44\n",
+      "34     yes  3.85  Advanced    Beginner         0               0      3.85\n",
+      "40     yes  3.95    Novice    Beginner         0               0      3.95\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "abd_addmitted_      int\n",
+      "abs_gpa_          float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'abs_gpa_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(abs_gpa_=abs_func_, abd_addmitted_=func.abs(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"abs_gpa_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### CASE_N function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function evaluates a list of conditions and returns the position of the first condition that evaluates to TRUE, \n",
+    "# provided that no prior condition in the list evaluates to UNKNOWN.\n",
+    "# Syntax:\n",
+    "#        TODO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "### CASE_N function\n",
+    "case_n_func_ = func.case_N(admissions_train.stats.expression == 'Novice', admissions_train.stats.expression == 'Beginner')\n",
+    "type(case_n_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, case_N(stats = 'Novice', stats = 'Beginner') AS case_n_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  case_n_func_\n",
+      "id                                                            \n",
+      "5       no  3.44    Novice      Novice         0           1.0\n",
+      "34     yes  3.85  Advanced    Beginner         0           NaN\n",
+      "13      no  4.00  Advanced      Novice         1           NaN\n",
+      "40     yes  3.95    Novice    Beginner         0           1.0\n",
+      "22     yes  3.46    Novice    Beginner         0           1.0\n",
+      "19     yes  1.98  Advanced    Advanced         0           NaN\n",
+      "36      no  3.00  Advanced      Novice         0           NaN\n",
+      "15     yes  4.00  Advanced    Advanced         1           NaN\n",
+      "7      yes  2.33    Novice      Novice         1           1.0\n",
+      "17      no  3.83  Advanced    Advanced         1           NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                int\n",
+      "masters           str\n",
+      "gpa             float\n",
+      "stats             str\n",
+      "programming       str\n",
+      "admitted          int\n",
+      "case_n_func_      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'case_n_func_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(case_n_func_=case_n_func_)\n",
+    "print_variables(df, \"case_n_func_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Ceiling or ceil function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the smallest integer value that is not less than the input argument.\n",
+    "# Syntax:\n",
+    "#        ceiling(column_expression) OR\n",
+    "#        ceil(column_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, ceiling(gpa) AS ceil_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  ceil_func_\n",
+      "id                                                          \n",
+      "22     yes  3.46    Novice    Beginner         0         4.0\n",
+      "36      no  3.00  Advanced      Novice         0         3.0\n",
+      "15     yes  4.00  Advanced    Advanced         1         4.0\n",
+      "38     yes  2.65  Advanced    Beginner         1         3.0\n",
+      "5       no  3.44    Novice      Novice         0         4.0\n",
+      "17      no  3.83  Advanced    Advanced         1         4.0\n",
+      "34     yes  3.85  Advanced    Beginner         0         4.0\n",
+      "13      no  4.00  Advanced      Novice         1         4.0\n",
+      "26     yes  3.57  Advanced    Advanced         1         4.0\n",
+      "19     yes  1.98  Advanced    Advanced         0         2.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "ceil_func_     float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'ceil_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for Ceiling \n",
+    "df = admissions_train.assign(ceil_func_ = func.ceiling(admissions_train.gpa.expression))\n",
+    "print_variables(df, \"ceil_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, ceil(gpa) AS ceil_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  ceil_func_\n",
+      "id                                                          \n",
+      "5       no  3.44    Novice      Novice         0         4.0\n",
+      "34     yes  3.85  Advanced    Beginner         0         4.0\n",
+      "13      no  4.00  Advanced      Novice         1         4.0\n",
+      "40     yes  3.95    Novice    Beginner         0         4.0\n",
+      "22     yes  3.46    Novice    Beginner         0         4.0\n",
+      "19     yes  1.98  Advanced    Advanced         0         2.0\n",
+      "36      no  3.00  Advanced      Novice         0         3.0\n",
+      "15     yes  4.00  Advanced    Advanced         1         4.0\n",
+      "7      yes  2.33    Novice      Novice         1         3.0\n",
+      "17      no  3.83  Advanced    Advanced         1         4.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "ceil_func_     float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'ceil_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for ceil\n",
+    "df = admissions_train.assign(ceil_func_ = func.ceil(admissions_train.gpa.expression))\n",
+    "print_variables(df, \"ceil_func_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Degrees & Radians functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# DEGREES takes a value specified in radians and converts it to degrees.\n",
+    "# Syntax:\n",
+    "#        degrees(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, degrees(1) AS degrees_const_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  degrees_const_func_\n",
+      "id                                                                   \n",
+      "15     yes  4.00  Advanced    Advanced         1             57.29578\n",
+      "7      yes  2.33    Novice      Novice         1             57.29578\n",
+      "22     yes  3.46    Novice    Beginner         0             57.29578\n",
+      "17      no  3.83  Advanced    Advanced         1             57.29578\n",
+      "13      no  4.00  Advanced      Novice         1             57.29578\n",
+      "38     yes  2.65  Advanced    Beginner         1             57.29578\n",
+      "26     yes  3.57  Advanced    Advanced         1             57.29578\n",
+      "5       no  3.44    Novice      Novice         0             57.29578\n",
+      "34     yes  3.85  Advanced    Beginner         0             57.29578\n",
+      "40     yes  3.95    Novice    Beginner         0             57.29578\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                       int\n",
+      "masters                  str\n",
+      "gpa                    float\n",
+      "stats                    str\n",
+      "programming              str\n",
+      "admitted                 int\n",
+      "degrees_const_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'degrees_const_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 1 for Degrees - Convert 1 radians to degrees\n",
+    "df = admissions_train.assign(degrees_const_func_ = func.degrees(1))\n",
+    "print_variables(df, \"degrees_const_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, degrees(admitted) AS degrees_admitted_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  degrees_admitted_func_\n",
+      "id                                                                      \n",
+      "5       no  3.44    Novice      Novice         0                 0.00000\n",
+      "34     yes  3.85  Advanced    Beginner         0                 0.00000\n",
+      "13      no  4.00  Advanced      Novice         1                57.29578\n",
+      "40     yes  3.95    Novice    Beginner         0                 0.00000\n",
+      "22     yes  3.46    Novice    Beginner         0                 0.00000\n",
+      "19     yes  1.98  Advanced    Advanced         0                 0.00000\n",
+      "36      no  3.00  Advanced      Novice         0                 0.00000\n",
+      "15     yes  4.00  Advanced    Advanced         1                57.29578\n",
+      "7      yes  2.33    Novice      Novice         1                57.29578\n",
+      "17      no  3.83  Advanced    Advanced         1                57.29578\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                          int\n",
+      "masters                     str\n",
+      "gpa                       float\n",
+      "stats                       str\n",
+      "programming                 str\n",
+      "admitted                    int\n",
+      "degrees_admitted_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'degrees_admitted_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 2 for Degrees - Convert values in admitted assuming they are in radians to degrees\n",
+    "df = admissions_train.assign(degrees_admitted_func_ = func.degrees(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"degrees_admitted_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# RADIANS takes a value specified in degrees and converts it to radians.\n",
+    "# Syntax:\n",
+    "#        radians(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, radians(90) AS radians_const_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  radians_const_func_\n",
+      "id                                                                   \n",
+      "15     yes  4.00  Advanced    Advanced         1             1.570796\n",
+      "7      yes  2.33    Novice      Novice         1             1.570796\n",
+      "22     yes  3.46    Novice    Beginner         0             1.570796\n",
+      "17      no  3.83  Advanced    Advanced         1             1.570796\n",
+      "13      no  4.00  Advanced      Novice         1             1.570796\n",
+      "38     yes  2.65  Advanced    Beginner         1             1.570796\n",
+      "26     yes  3.57  Advanced    Advanced         1             1.570796\n",
+      "5       no  3.44    Novice      Novice         0             1.570796\n",
+      "34     yes  3.85  Advanced    Beginner         0             1.570796\n",
+      "40     yes  3.95    Novice    Beginner         0             1.570796\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                       int\n",
+      "masters                  str\n",
+      "gpa                    float\n",
+      "stats                    str\n",
+      "programming              str\n",
+      "admitted                 int\n",
+      "radians_const_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'radians_const_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 1 for Radians - Convert 90 degrees to radians\n",
+    "df = admissions_train.assign(radians_const_func_ = func.radians(90))\n",
+    "print_variables(df, \"radians_const_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, RADIANS(admitted) AS radians_admitted_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  radians_admitted_func_\n",
+      "id                                                                      \n",
+      "5       no  3.44    Novice      Novice         0                0.000000\n",
+      "34     yes  3.85  Advanced    Beginner         0                0.000000\n",
+      "13      no  4.00  Advanced      Novice         1                0.017453\n",
+      "40     yes  3.95    Novice    Beginner         0                0.000000\n",
+      "22     yes  3.46    Novice    Beginner         0                0.000000\n",
+      "19     yes  1.98  Advanced    Advanced         0                0.000000\n",
+      "36      no  3.00  Advanced      Novice         0                0.000000\n",
+      "15     yes  4.00  Advanced    Advanced         1                0.017453\n",
+      "7      yes  2.33    Novice      Novice         1                0.017453\n",
+      "17      no  3.83  Advanced    Advanced         1                0.017453\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                          int\n",
+      "masters                     str\n",
+      "gpa                       float\n",
+      "stats                       str\n",
+      "programming                 str\n",
+      "admitted                    int\n",
+      "radians_admitted_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'radians_admitted_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 2 for Degrees - Convert values in gpa assuming they are in degrees to radians\n",
+    "df = admissions_train.assign(radians_admitted_func_ = func.RADIANS(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"radians_admitted_func_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### EXP function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function raises e (the base of natural logarithms) to the power of the argument, where e = 2.71828182845905.\n",
+    "# Syntax: \n",
+    "#        exp(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, exp(admitted) AS exp_admitted_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  exp_admitted_func_\n",
+      "id                                                                  \n",
+      "15     yes  4.00  Advanced    Advanced         1            2.718282\n",
+      "7      yes  2.33    Novice      Novice         1            2.718282\n",
+      "22     yes  3.46    Novice    Beginner         0            1.000000\n",
+      "17      no  3.83  Advanced    Advanced         1            2.718282\n",
+      "13      no  4.00  Advanced      Novice         1            2.718282\n",
+      "38     yes  2.65  Advanced    Beginner         1            2.718282\n",
+      "26     yes  3.57  Advanced    Advanced         1            2.718282\n",
+      "5       no  3.44    Novice      Novice         0            1.000000\n",
+      "34     yes  3.85  Advanced    Beginner         0            1.000000\n",
+      "40     yes  3.95    Novice    Beginner         0            1.000000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                      int\n",
+      "masters                 str\n",
+      "gpa                   float\n",
+      "stats                   str\n",
+      "programming             str\n",
+      "admitted                int\n",
+      "exp_admitted_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'exp_admitted_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 1: Calculate exp of values in column admitted\n",
+    "df = admissions_train.assign(exp_admitted_func_ = func.exp(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"exp_admitted_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, exp(admitted) AS exp_const_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  exp_const_func_\n",
+      "id                                                               \n",
+      "5       no  3.44    Novice      Novice         0         1.000000\n",
+      "34     yes  3.85  Advanced    Beginner         0         1.000000\n",
+      "13      no  4.00  Advanced      Novice         1         2.718282\n",
+      "40     yes  3.95    Novice    Beginner         0         1.000000\n",
+      "22     yes  3.46    Novice    Beginner         0         1.000000\n",
+      "19     yes  1.98  Advanced    Advanced         0         1.000000\n",
+      "36      no  3.00  Advanced      Novice         0         1.000000\n",
+      "15     yes  4.00  Advanced    Advanced         1         2.718282\n",
+      "7      yes  2.33    Novice      Novice         1         2.718282\n",
+      "17      no  3.83  Advanced    Advanced         1         2.718282\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                   int\n",
+      "masters              str\n",
+      "gpa                float\n",
+      "stats                str\n",
+      "programming          str\n",
+      "admitted             int\n",
+      "exp_const_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'exp_const_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case 2: Calculate exp of 2\n",
+    "df = admissions_train.assign(exp_const_func_ = func.exp(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"exp_const_func_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### FLOOR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the largest integer equal to or less than the input argument.\n",
+    "# Syntax:\n",
+    "#         floor(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, floor(gpa) AS floor_gpa_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  floor_gpa_func_\n",
+      "id                                                               \n",
+      "22     yes  3.46    Novice    Beginner         0              3.0\n",
+      "36      no  3.00  Advanced      Novice         0              3.0\n",
+      "15     yes  4.00  Advanced    Advanced         1              4.0\n",
+      "38     yes  2.65  Advanced    Beginner         1              2.0\n",
+      "5       no  3.44    Novice      Novice         0              3.0\n",
+      "17      no  3.83  Advanced    Advanced         1              3.0\n",
+      "34     yes  3.85  Advanced    Beginner         0              3.0\n",
+      "13      no  4.00  Advanced      Novice         1              4.0\n",
+      "26     yes  3.57  Advanced    Advanced         1              3.0\n",
+      "19     yes  1.98  Advanced    Advanced         0              1.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                   int\n",
+      "masters              str\n",
+      "gpa                float\n",
+      "stats                str\n",
+      "programming          str\n",
+      "admitted             int\n",
+      "floor_gpa_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'floor_gpa_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case: Calculate floor of values in column gpa \n",
+    "df = admissions_train.assign(floor_gpa_func_ = func.floor(admissions_train.gpa.expression))\n",
+    "print_variables(df, \"floor_gpa_func_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, FLOOR(2.43) AS floor_gpa_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  floor_gpa_func_\n",
+      "id                                                               \n",
+      "5       no  3.44    Novice      Novice         0              2.0\n",
+      "34     yes  3.85  Advanced    Beginner         0              2.0\n",
+      "13      no  4.00  Advanced      Novice         1              2.0\n",
+      "40     yes  3.95    Novice    Beginner         0              2.0\n",
+      "22     yes  3.46    Novice    Beginner         0              2.0\n",
+      "19     yes  1.98  Advanced    Advanced         0              2.0\n",
+      "36      no  3.00  Advanced      Novice         0              2.0\n",
+      "15     yes  4.00  Advanced    Advanced         1              2.0\n",
+      "7      yes  2.33    Novice      Novice         1              2.0\n",
+      "17      no  3.83  Advanced    Advanced         1              2.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                   int\n",
+      "masters              str\n",
+      "gpa                float\n",
+      "stats                str\n",
+      "programming          str\n",
+      "admitted             int\n",
+      "floor_gpa_func_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'floor_gpa_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case: Calculate floor of constant value 2.43\n",
+    "df = admissions_train.assign(floor_gpa_func_ = func.FLOOR(2.43))\n",
+    "print_variables(df, \"floor_gpa_func_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Hyperbolic Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# These functions perform the hyperbolic or inverse hyperbolic function of an argument.\n",
+    "# Following hyperbolic function are available:\n",
+    "# - COSH(column_expression/constant)\n",
+    "# - SINH(column_expression/constant)\n",
+    "# - TANH(column_expression/constant)\n",
+    "# - ACOSH(column_expression/constant)\n",
+    "# - ASINH(column_expression/constant)\n",
+    "# - ATANH(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, ASINH(sinh(gpa)) AS asinh_gpa_func_, sinh(gpa) AS sinh_gpa_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  asinh_gpa_func_  sinh_gpa_func_\n",
+      "id                                                                               \n",
+      "22     yes  3.46    Novice    Beginner         0             3.46       15.892773\n",
+      "36      no  3.00  Advanced      Novice         0             3.00       10.017875\n",
+      "15     yes  4.00  Advanced    Advanced         1             4.00       27.289917\n",
+      "38     yes  2.65  Advanced    Beginner         1             2.65        7.041694\n",
+      "5       no  3.44    Novice      Novice         0             3.44       15.577447\n",
+      "17      no  3.83  Advanced    Advanced         1             3.83       23.020414\n",
+      "34     yes  3.85  Advanced    Beginner         0             3.85       23.485892\n",
+      "13      no  4.00  Advanced      Novice         1             4.00       27.289917\n",
+      "26     yes  3.57  Advanced    Advanced         1             3.57       17.744219\n",
+      "19     yes  1.98  Advanced    Advanced         0             1.98        3.552337\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                   int\n",
+      "masters              str\n",
+      "gpa                float\n",
+      "stats                str\n",
+      "programming          str\n",
+      "admitted             int\n",
+      "asinh_gpa_func_    float\n",
+      "sinh_gpa_func_     float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'sinh_gpa_func_' Column Type: FLOAT\n",
+      " 'asinh_gpa_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for SINH and ASINH functions, other functions can also be used in similar way\n",
+    "df = admissions_train.assign(sinh_gpa_func_ = func.sinh(admissions_train.gpa.expression), \n",
+    "                        asinh_gpa_func_ = func.ASINH(func.sinh(admissions_train.gpa.expression)))\n",
+    "print_variables(df, [\"sinh_gpa_func_\", \"asinh_gpa_func_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Logarithmic Functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LN fucntion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compute the natural logarithm of the argument. \n",
+    "# Syntax:\n",
+    "#        ln(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, LN(10) AS natural_log_const_func_, LN(gpa) AS natural_log_gpa_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  natural_log_const_func_  natural_log_gpa_func_\n",
+      "id                                                                                              \n",
+      "5       no  3.44    Novice      Novice         0                 2.302585               1.235471\n",
+      "7      yes  2.33    Novice      Novice         1                 2.302585               0.845868\n",
+      "22     yes  3.46    Novice    Beginner         0                 2.302585               1.241269\n",
+      "19     yes  1.98  Advanced    Advanced         0                 2.302585               0.683097\n",
+      "15     yes  4.00  Advanced    Advanced         1                 2.302585               1.386294\n",
+      "17      no  3.83  Advanced    Advanced         1                 2.302585               1.342865\n",
+      "34     yes  3.85  Advanced    Beginner         0                 2.302585               1.348073\n",
+      "13      no  4.00  Advanced      Novice         1                 2.302585               1.386294\n",
+      "36      no  3.00  Advanced      Novice         0                 2.302585               1.098612\n",
+      "40     yes  3.95    Novice    Beginner         0                 2.302585               1.373716\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                           int\n",
+      "masters                      str\n",
+      "gpa                        float\n",
+      "stats                        str\n",
+      "programming                  str\n",
+      "admitted                     int\n",
+      "natural_log_const_func_    float\n",
+      "natural_log_gpa_func_      float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'natural_log_gpa_func_' Column Type: FLOAT\n",
+      " 'natural_log_const_func_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute natural logarithm of values in gpa and a constant 10\n",
+    "df = admissions_train.assign(natural_log_gpa_func_ = func.LN(admissions_train.gpa.expression),\n",
+    "                       natural_log_const_func_ = func.LN(10))\n",
+    "print_variables(df, [\"natural_log_gpa_func_\", \"natural_log_const_func_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LOG function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function computes the base 10 logarithm of an argument.\n",
+    "# Syntax:\n",
+    "#        LOG(column_expression/constant)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, log(10) AS log_const_func, Log(gpa * 10) AS log_gpa_func_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  log_const_func  log_gpa_func_\n",
+      "id                                                                             \n",
+      "22     yes  3.46    Novice    Beginner         0             1.0       1.539076\n",
+      "26     yes  3.57  Advanced    Advanced         1             1.0       1.552668\n",
+      "5       no  3.44    Novice      Novice         0             1.0       1.536558\n",
+      "17      no  3.83  Advanced    Advanced         1             1.0       1.583199\n",
+      "13      no  4.00  Advanced      Novice         1             1.0       1.602060\n",
+      "19     yes  1.98  Advanced    Advanced         0             1.0       1.296665\n",
+      "36      no  3.00  Advanced      Novice         0             1.0       1.477121\n",
+      "15     yes  4.00  Advanced    Advanced         1             1.0       1.602060\n",
+      "34     yes  3.85  Advanced    Beginner         0             1.0       1.585461\n",
+      "38     yes  2.65  Advanced    Beginner         1             1.0       1.423246\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "log_const_func    float\n",
+      "log_gpa_func_     float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'log_gpa_func_' Column Type: FLOAT\n",
+      " 'log_const_func' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute natural logarithm of values in gpa * 10 and a constant 10\n",
+    "df = admissions_train.assign(log_gpa_func_ = func.Log(admissions_train.gpa.expression * 10),\n",
+    "                       log_const_func = func.log(10))\n",
+    "print_variables(df, [\"log_gpa_func_\", \"log_const_func\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MOD Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the remainder (modulus) of expr1 divided by expr2.\n",
+    "# Syntax:\n",
+    "#        MOD(expr1, expr2)\n",
+    "#        Where, \n",
+    "#                expr1 and expr2 can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, MOD(12, gpa) AS modgpa12, mod(gpa, 2) AS modgpa2 from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  modgpa12  modgpa2\n",
+      "id                                                                 \n",
+      "5       no  3.44    Novice      Novice         0      1.68     1.44\n",
+      "34     yes  3.85  Advanced    Beginner         0      0.45     1.85\n",
+      "13      no  4.00  Advanced      Novice         1      0.00     0.00\n",
+      "40     yes  3.95    Novice    Beginner         0      0.15     1.95\n",
+      "22     yes  3.46    Novice    Beginner         0      1.62     1.46\n",
+      "19     yes  1.98  Advanced    Advanced         0      0.12     1.98\n",
+      "36      no  3.00  Advanced      Novice         0      0.00     1.00\n",
+      "15     yes  4.00  Advanced    Advanced         1      0.00     0.00\n",
+      "7      yes  2.33    Novice      Novice         1      0.35     0.33\n",
+      "17      no  3.83  Advanced    Advanced         1      0.51     1.83\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "modgpa12       float\n",
+      "modgpa2        float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'modgpa2' Column Type: FLOAT\n",
+      " 'modgpa12' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for MOD function\n",
+    "df = admissions_train.assign(modgpa2 = func.mod(admissions_train.gpa.expression, 2),\n",
+    "                       modgpa12 = func.MOD(12, admissions_train.gpa.expression),)\n",
+    "print_variables(df, [\"modgpa2\", \"modgpa12\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## NULL to 0 and vice versa conversion functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### NULLIFZERO functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function converts data from zero to null to avoid problems with division by zero.\n",
+    "# Syntax:\n",
+    "#        NULLIFZERO(expr)\n",
+    "#        Where, \n",
+    "#                expr - can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, gpa / nullifzero(admitted) AS admitted_null_if_zero from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  admitted_null_if_zero\n",
+      "id                                                                     \n",
+      "15     yes  4.00  Advanced    Advanced         1                   4.00\n",
+      "7      yes  2.33    Novice      Novice         1                   2.33\n",
+      "22     yes  3.46    Novice    Beginner         0                    NaN\n",
+      "17      no  3.83  Advanced    Advanced         1                   3.83\n",
+      "13      no  4.00  Advanced      Novice         1                   4.00\n",
+      "38     yes  2.65  Advanced    Beginner         1                   2.65\n",
+      "26     yes  3.57  Advanced    Advanced         1                   3.57\n",
+      "5       no  3.44    Novice      Novice         0                    NaN\n",
+      "34     yes  3.85  Advanced    Beginner         0                    NaN\n",
+      "40     yes  3.95    Novice    Beginner         0                    NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                         int\n",
+      "masters                    str\n",
+      "gpa                      float\n",
+      "stats                      str\n",
+      "programming                str\n",
+      "admitted                   int\n",
+      "admitted_null_if_zero    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'admitted_null_if_zero' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case of NULLIFZERO function - Function can be used, when we are dividing by a column that may contain 0, \n",
+    "# so that we can avoid errors coming from expressions such as:\n",
+    "#         8 / 0\n",
+    "# Note:\n",
+    "#        In this example, we have combined teradataml ColumnExpression and SQLAlchemy func object\n",
+    "#        admissions_train.gpa -- Is a teradataml ColumnExpression\n",
+    "#        func.nullifzero(admissions_train.admitted.expression) -- Is SQLAlchemy func object\n",
+    "df = admissions_train.assign(admitted_null_if_zero = admissions_train.gpa / func.nullifzero(admissions_train.admitted.expression))\n",
+    "print_variables(df, \"admitted_null_if_zero\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ZEROIFNULL Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function converts data from null to 0 to avoid cases where a null result creates an error.\n",
+    "# Syntax:\n",
+    "#        ZEROIFNULL(expr)\n",
+    "#        Where, \n",
+    "#                expr - can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, gpa / nullifzero(admitted) AS admitted_null_if_zero, zeroifnull(gpa / nullifzero(admitted)) AS admitted_zero_if_null from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  admitted_null_if_zero  admitted_zero_if_null\n",
+      "id                                                                                            \n",
+      "13      no  4.00  Advanced      Novice         1                   4.00  4.00000000000000E 000\n",
+      "26     yes  3.57  Advanced    Advanced         1                   3.57  3.57000000000000E 000\n",
+      "5       no  3.44    Novice      Novice         0                    NaN  0.00000000000000E 000\n",
+      "19     yes  1.98  Advanced    Advanced         0                    NaN  0.00000000000000E 000\n",
+      "15     yes  4.00  Advanced    Advanced         1                   4.00  4.00000000000000E 000\n",
+      "40     yes  3.95    Novice    Beginner         0                    NaN  0.00000000000000E 000\n",
+      "7      yes  2.33    Novice      Novice         1                   2.33  2.33000000000000E 000\n",
+      "22     yes  3.46    Novice    Beginner         0                    NaN  0.00000000000000E 000\n",
+      "36      no  3.00  Advanced      Novice         0                    NaN  0.00000000000000E 000\n",
+      "38     yes  2.65  Advanced    Beginner         1                   2.65  2.65000000000000E 000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                         int\n",
+      "masters                    str\n",
+      "gpa                      float\n",
+      "stats                      str\n",
+      "programming                str\n",
+      "admitted                   int\n",
+      "admitted_null_if_zero    float\n",
+      "admitted_zero_if_null      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'admitted_null_if_zero' Column Type: FLOAT\n",
+      " 'admitted_zero_if_null' Column Type: NullType\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note:\n",
+    "#        In this example, we have combined teradataml ColumnExpression and SQLAlchemy func object\n",
+    "#        admissions_train.gpa -- Is a teradataml ColumnExpression\n",
+    "#        func.nullifzero(admissions_train.admitted.expression) -- Is SQLAlchemy func object\n",
+    "df = admissions_train.assign(admitted_null_if_zero = admissions_train.gpa / func.nullifzero(admissions_train.admitted.expression),\n",
+    "                       admitted_zero_if_null = func.zeroifnull(\n",
+    "                           admissions_train.gpa.expression / func.nullifzero(admissions_train.admitted.expression)))\n",
+    "print_variables(df, [\"admitted_null_if_zero\", \"admitted_zero_if_null\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### POWER function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns base_value raised to the power of exponent_value.\n",
+    "# Syntax:\n",
+    "#        power(expr1, expr2)\n",
+    "#        Where, \n",
+    "#                expr1 and expr2 can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, power(gpa, 2) AS pow2gpa, power(gpa, admitted) AS pow_admitted_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  pow2gpa  pow_admitted_gpa\n",
+      "id                                                                         \n",
+      "13      no  4.00  Advanced      Novice         1  16.0000              4.00\n",
+      "26     yes  3.57  Advanced    Advanced         1  12.7449              3.57\n",
+      "5       no  3.44    Novice      Novice         0  11.8336              1.00\n",
+      "19     yes  1.98  Advanced    Advanced         0   3.9204              1.00\n",
+      "15     yes  4.00  Advanced    Advanced         1  16.0000              4.00\n",
+      "40     yes  3.95    Novice    Beginner         0  15.6025              1.00\n",
+      "7      yes  2.33    Novice      Novice         1   5.4289              2.33\n",
+      "22     yes  3.46    Novice    Beginner         0  11.9716              1.00\n",
+      "36      no  3.00  Advanced      Novice         0   9.0000              1.00\n",
+      "38     yes  2.65  Advanced    Beginner         1   7.0225              2.65\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                    int\n",
+      "masters               str\n",
+      "gpa                 float\n",
+      "stats                 str\n",
+      "programming           str\n",
+      "admitted              int\n",
+      "pow2gpa             float\n",
+      "pow_admitted_gpa    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'pow2gpa' Column Type: FLOAT\n",
+      " 'pow_admitted_gpa' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case POWER function:\n",
+    "# Find square of values in gpa column and gpa as base value raised to the value in admitted.\n",
+    "df = admissions_train.assign(pow2gpa = func.power(admissions_train.gpa.expression, 2),\n",
+    "                       pow_admitted_gpa = func.power(admissions_train.gpa.expression, admissions_train.admitted.expression))\n",
+    "print_variables(df, [\"pow2gpa\", \"pow_admitted_gpa\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Round Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns numeric_value rounded places_value places to the right or left of the decimal point.\n",
+    "# Syntax:\n",
+    "#        ROUND(expr1, expr2)\n",
+    "#        Where, \n",
+    "#                expr1 and expr2 can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, ROUND(2.433412, 3) AS round_const_3, Round(gpa, 1) AS round_gpa_1, round(gpa, admitted) AS round_gpa_admitted from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  round_const_3  round_gpa_1  round_gpa_admitted\n",
+      "id                                                                                              \n",
+      "5       no  3.44    Novice      Novice         0          2.433          3.4                 3.0\n",
+      "34     yes  3.85  Advanced    Beginner         0          2.433          3.9                 4.0\n",
+      "13      no  4.00  Advanced      Novice         1          2.433          4.0                 4.0\n",
+      "40     yes  3.95    Novice    Beginner         0          2.433          4.0                 4.0\n",
+      "22     yes  3.46    Novice    Beginner         0          2.433          3.5                 3.0\n",
+      "19     yes  1.98  Advanced    Advanced         0          2.433          2.0                 2.0\n",
+      "36      no  3.00  Advanced      Novice         0          2.433          3.0                 3.0\n",
+      "15     yes  4.00  Advanced    Advanced         1          2.433          4.0                 4.0\n",
+      "7      yes  2.33    Novice      Novice         1          2.433          2.3                 2.3\n",
+      "17      no  3.83  Advanced    Advanced         1          2.433          3.8                 3.8\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                      int\n",
+      "masters                 str\n",
+      "gpa                   float\n",
+      "stats                   str\n",
+      "programming             str\n",
+      "admitted                int\n",
+      "round_const_3         float\n",
+      "round_gpa_1           float\n",
+      "round_gpa_admitted    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'round_gpa_1' Column Type: FLOAT\n",
+      " 'round_gpa_admitted' Column Type: FLOAT\n",
+      " 'round_const_3' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example use cases for Round\n",
+    "df = admissions_train.assign(round_gpa_1 = func.Round(admissions_train.gpa.expression, 1),\n",
+    "                       round_gpa_admitted = func.round(admissions_train.gpa.expression, admissions_train.admitted.expression),\n",
+    "                       round_const_3 = func.ROUND(2.433412, 3))\n",
+    "print_variables(df, [\"round_gpa_1\", \"round_gpa_admitted\", \"round_const_3\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SIGN Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the sign of numeric_value.\n",
+    "# Syntax:\n",
+    "#        sign(expr)\n",
+    "#        Where, \n",
+    "#                expr can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sign(-3) AS sign_const, sign(gpa) AS sign_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted sign_const sign_gpa\n",
+      "id                                                                  \n",
+      "22     yes  3.46    Novice    Beginner         0         -1        1\n",
+      "26     yes  3.57  Advanced    Advanced         1         -1        1\n",
+      "5       no  3.44    Novice      Novice         0         -1        1\n",
+      "17      no  3.83  Advanced    Advanced         1         -1        1\n",
+      "13      no  4.00  Advanced      Novice         1         -1        1\n",
+      "19     yes  1.98  Advanced    Advanced         0         -1        1\n",
+      "36      no  3.00  Advanced      Novice         0         -1        1\n",
+      "15     yes  4.00  Advanced    Advanced         1         -1        1\n",
+      "34     yes  3.85  Advanced    Beginner         0         -1        1\n",
+      "38     yes  2.65  Advanced    Beginner         1         -1        1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                         int\n",
+      "masters                    str\n",
+      "gpa                      float\n",
+      "stats                      str\n",
+      "programming                str\n",
+      "admitted                   int\n",
+      "sign_const     decimal.Decimal\n",
+      "sign_gpa       decimal.Decimal\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'sign_gpa' Column Type: NUMBER\n",
+      " 'sign_const' Column Type: NUMBER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# SIGN function\n",
+    "df = admissions_train.assign(sign_gpa = func.sign(admissions_train.gpa.expression),\n",
+    "                        sign_const = func.sign(-3))\n",
+    "print_variables(df, [\"sign_gpa\", \"sign_const\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SQRT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Computes the square root of an argument.\n",
+    "# Syntax:\n",
+    "#        sqrt(expr)\n",
+    "#        Where, \n",
+    "#                expr can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, SQRT(25) AS sqrt_const, sqrt(gpa) AS sqrt_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqrt_const  sqrt_gpa\n",
+      "id                                                                    \n",
+      "5       no  3.44    Novice      Novice         0         5.0  1.854724\n",
+      "34     yes  3.85  Advanced    Beginner         0         5.0  1.962142\n",
+      "13      no  4.00  Advanced      Novice         1         5.0  2.000000\n",
+      "40     yes  3.95    Novice    Beginner         0         5.0  1.987461\n",
+      "22     yes  3.46    Novice    Beginner         0         5.0  1.860108\n",
+      "19     yes  1.98  Advanced    Advanced         0         5.0  1.407125\n",
+      "36      no  3.00  Advanced      Novice         0         5.0  1.732051\n",
+      "15     yes  4.00  Advanced    Advanced         1         5.0  2.000000\n",
+      "7      yes  2.33    Novice      Novice         1         5.0  1.526434\n",
+      "17      no  3.83  Advanced    Advanced         1         5.0  1.957039\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "sqrt_const     float\n",
+      "sqrt_gpa       float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'sqrt_gpa' Column Type: FLOAT\n",
+      " 'sqrt_const' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for sqrt function\n",
+    "df = admissions_train.assign(sqrt_gpa = func.sqrt(admissions_train.gpa.expression),\n",
+    "                        sqrt_const = func.SQRT(25))\n",
+    "print_variables(df, [\"sqrt_gpa\", \"sqrt_const\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Trignometric Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# These functions perform the trigonometric or inverse trigonometric function of an argument.\n",
+    "# Following hyperbolic function are available:\n",
+    "# - COS(expr)\n",
+    "# - SIN(expr)\n",
+    "# - TAN(expr)\n",
+    "# - ACOS(expr)\n",
+    "# - ASIN(expr)\n",
+    "# - ATAN(expr)\n",
+    "# - ATAN2(x,y)\n",
+    "#        Where, \n",
+    "#                expr can be column_expression or a constant\n",
+    "#                x - The x-coordinate of a point to use in the arctangent calculation.\n",
+    "#                y - The y-coordinate of a point to use in the arctangent calculation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, acos(admitted) AS acos_admitted, asin(admitted) AS asin_admitted, atan2(1, 1) AS atan2_admitted, atan(admitted) AS atan_admitted, cos(admitted) AS cos_admitted, sin(admitted) AS sin_admitted, tan(admitted) AS tan_admitted from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  acos_admitted  asin_admitted  atan2_admitted  atan_admitted  cos_admitted  sin_admitted  tan_admitted\n",
+      "id                                                                                                                                                     \n",
+      "22     yes  3.46    Novice    Beginner         0       1.570796       0.000000        0.785398       0.000000      1.000000      0.000000      0.000000\n",
+      "36      no  3.00  Advanced      Novice         0       1.570796       0.000000        0.785398       0.000000      1.000000      0.000000      0.000000\n",
+      "15     yes  4.00  Advanced    Advanced         1       0.000000       1.570796        0.785398       0.785398      0.540302      0.841471      1.557408\n",
+      "38     yes  2.65  Advanced    Beginner         1       0.000000       1.570796        0.785398       0.785398      0.540302      0.841471      1.557408\n",
+      "5       no  3.44    Novice      Novice         0       1.570796       0.000000        0.785398       0.000000      1.000000      0.000000      0.000000\n",
+      "17      no  3.83  Advanced    Advanced         1       0.000000       1.570796        0.785398       0.785398      0.540302      0.841471      1.557408\n",
+      "34     yes  3.85  Advanced    Beginner         0       1.570796       0.000000        0.785398       0.000000      1.000000      0.000000      0.000000\n",
+      "13      no  4.00  Advanced      Novice         1       0.000000       1.570796        0.785398       0.785398      0.540302      0.841471      1.557408\n",
+      "26     yes  3.57  Advanced    Advanced         1       0.000000       1.570796        0.785398       0.785398      0.540302      0.841471      1.557408\n",
+      "19     yes  1.98  Advanced    Advanced         0       1.570796       0.000000        0.785398       0.000000      1.000000      0.000000      0.000000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "acos_admitted     float\n",
+      "asin_admitted     float\n",
+      "atan2_admitted    float\n",
+      "atan_admitted     float\n",
+      "cos_admitted      float\n",
+      "sin_admitted      float\n",
+      "tan_admitted      float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'cos_admitted' Column Type: FLOAT\n",
+      " 'sin_admitted' Column Type: FLOAT\n",
+      " 'acos_admitted' Column Type: FLOAT\n",
+      " 'asin_admitted' Column Type: FLOAT\n",
+      " 'tan_admitted' Column Type: FLOAT\n",
+      " 'atan_admitted' Column Type: FLOAT\n",
+      " 'atan2_admitted' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use case for trignometric function\n",
+    "df = admissions_train.assign(cos_admitted = func.cos(admissions_train.admitted.expression),\n",
+    "                        sin_admitted = func.sin(admissions_train.admitted.expression),\n",
+    "                        acos_admitted = func.acos(admissions_train.admitted.expression),\n",
+    "                        asin_admitted = func.asin(admissions_train.admitted.expression),\n",
+    "                        tan_admitted = func.tan(admissions_train.admitted.expression),\n",
+    "                        atan_admitted = func.atan(admissions_train.admitted.expression),\n",
+    "                        atan2_admitted = func.atan2(1,1))\n",
+    "print_variables(df, [\"cos_admitted\", \"sin_admitted\", \"acos_admitted\", \"asin_admitted\", \"tan_admitted\", \"atan_admitted\", \"atan2_admitted\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### TRUNC Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns expr1 truncated expr2 places to the right or left of the decimal point.\n",
+    "# Syntax:\n",
+    "#        TRUNC(expr1, expr2)\n",
+    "#        Where, \n",
+    "#                expr1 and expr2 can be column_expression or a constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, Trunc(2.433412, -3) AS trunc_const_3, TRUNC(gpa, 1) AS trunc_gpa_1, trunc(gpa, admitted) AS trunc_gpa_admitted from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  trunc_const_3  trunc_gpa_1  trunc_gpa_admitted\n",
+      "id                                                                                              \n",
+      "5       no  3.44    Novice      Novice         0            0.0          3.4                 3.0\n",
+      "7      yes  2.33    Novice      Novice         1            0.0          2.3                 2.3\n",
+      "22     yes  3.46    Novice    Beginner         0            0.0          3.4                 3.0\n",
+      "19     yes  1.98  Advanced    Advanced         0            0.0          1.9                 1.0\n",
+      "15     yes  4.00  Advanced    Advanced         1            0.0          4.0                 4.0\n",
+      "17      no  3.83  Advanced    Advanced         1            0.0          3.8                 3.8\n",
+      "34     yes  3.85  Advanced    Beginner         0            0.0          3.8                 3.0\n",
+      "13      no  4.00  Advanced      Novice         1            0.0          4.0                 4.0\n",
+      "36      no  3.00  Advanced      Novice         0            0.0          3.0                 3.0\n",
+      "40     yes  3.95    Novice    Beginner         0            0.0          3.9                 3.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                      int\n",
+      "masters                 str\n",
+      "gpa                   float\n",
+      "stats                   str\n",
+      "programming             str\n",
+      "admitted                int\n",
+      "trunc_const_3         float\n",
+      "trunc_gpa_1           float\n",
+      "trunc_gpa_admitted    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'trunc_gpa_1' Column Type: FLOAT\n",
+      " 'trunc_gpa_admitted' Column Type: FLOAT\n",
+      " 'trunc_const_3' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example use cases for TRUNC\n",
+    "df = admissions_train.assign(trunc_gpa_1 = func.TRUNC(admissions_train.gpa.expression, 1),\n",
+    "                       trunc_gpa_admitted = func.trunc(admissions_train.gpa.expression, admissions_train.admitted.expression),\n",
+    "                       trunc_const_3 = func.Trunc(2.433412, -3))\n",
+    "print_variables(df, [\"trunc_gpa_1\", \"trunc_gpa_admitted\", \"trunc_const_3\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### WIDTH_BUCKET Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the number of the partition to which value_expression is assigned.\n",
+    "# Syntax:\n",
+    "#        width_bucket(value_expression, lower_bound, upper_bound, partition_count)\n",
+    "#        Where,\n",
+    "#                value_expression - Column for which a partition number is to be returned.\n",
+    "#                lower_bound - The lower boundary for the range of values to be partitioned equally.\n",
+    "#                upper_bound - The upper boundary for the range of values to be partitioned equally.\n",
+    "#                partition_count - Number of partitions to be created. \n",
+    "#                                  This value also specifies the width of the partitions by default.\n",
+    "#                                  The number of partitions created is partition_count + 2. \n",
+    "#                                  Partition 0 and partition partition_count + 1 account for values of \n",
+    "#                                  value_expression that are outside the lower and upper boundaries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, Width_bucket(gpa, 2.5, 3.5, 3) AS bucket_gpa_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  bucket_gpa_\n",
+      "id                                                           \n",
+      "15     yes  4.00  Advanced    Advanced         1            4\n",
+      "7      yes  2.33    Novice      Novice         1            0\n",
+      "22     yes  3.46    Novice    Beginner         0            3\n",
+      "17      no  3.83  Advanced    Advanced         1            4\n",
+      "13      no  4.00  Advanced      Novice         1            4\n",
+      "38     yes  2.65  Advanced    Beginner         1            1\n",
+      "26     yes  3.57  Advanced    Advanced         1            4\n",
+      "5       no  3.44    Novice      Novice         0            3\n",
+      "34     yes  3.85  Advanced    Beginner         0            4\n",
+      "40     yes  3.95    Novice    Beginner         0            4\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "bucket_gpa_      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'bucket_gpa_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example use case for width_bucket\n",
+    "df = admissions_train.assign(bucket_gpa_ = func.Width_bucket(admissions_train.gpa.expression, 2.5, 3.5, 3))\n",
+    "print_variables(df, \"bucket_gpa_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# RANDOM, RANGE_N --> Need investigation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# One must run remove_context() to close the connection and garbage collect internally generated objects.\n",
+    "remove_context()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}