/* This program demonstrates
 * 1. Nested Loops
 * 2. Deriving loop conditions from patterns
 * 3. Introduction to functions from the caller perspective
 * 4. Introduction to functions from the builder perspective
 *
 * Deriving loop conditions and formulae in general from examples.
 * Sometimes, it not obvious how many times a loop should run.
 * In this case, we can write out a few examples, and derive a formula for
 * the number of iterations from those examples.
 *
 * Functions
 * Functions are small modules of code. They are considered to be a unit
 * consisting of a few lines of code that solves a particular problem.
 * Functions usually serve only one pruprose. For example, we can write a
 * function to find out if a number is prime, and aother to find the area
 * of a circle, but we will ideally never combine the two.
 *
 * C++ already offers a variety of pre-defined (pre-implemented) functions
 * through libraries. To use a particular function, we just need to include
 * the library that contains the function. For example, in this program, we
 * will use the functions in the math library.
 *
 * cmath is a C++ library that contains several functions that will
 * solve select math problems.
 * You can look up the cmath reference at cplusplus.com
 *
 * User(Programmers, as the "users" of C++) Defined Functions
 * Programmers can also write their own functions. These are called user-defines
 * functions. Here, we are the user (for C++), just like we call someone running
 * our program, the user.
 *
 * Functions have the following syntax:
 * return_type name ( list of arguments)
 * 1. The name of the function is whatever we are calling this function. Function
 *    names are identifiers, so we should follow the rules and conventions for
 *    naming identifiers, just like we do with variables.
 * 2. The list of arguments is a comma separated list of variables that are sent
 *    into the function. These are also called parameters. Each of the parameters
 *    requires its own type, even if they are all the same type.
 * 3. The return_type is the type of data that the function is going to send back
 *    to the place it was called from.
 *
 *  Writing/Using a function is done in 3 steps.
 * 1. Declaration/Prototyping: This is the process of telling C++ that we are
 *    going to write a function. The declaration contains the return type, name
 *    and the list of arguments, followed by a semi-colon. The names of the
 *    arguments are optional. Only the types are required at this stage. The
 *    declaration should be placed BEFORE the main function.
 *
 * 2. Defining the function: This is the process of actually writing the function.
 *    The definition typically goes AFTER main. While defining the function, we
 *    should match the function name, return type, and the number, order and
 *    types of the parameters with the function declaration. The names of the
 *    parameters do not have to match.
 *
 * 3. Function Call: This is where we use the function we just wrote. The function
 *    call is usually in main/some other function. Once again, we have to match
 *    the function name and the number, order and types of the parameters. The
 *    value returned from the function should be stored into a variable of a
 *    compatible type. To call  function, we use the name, and give values to
 *    the parameters (using literals, variable or constants).
 */

#include<iostream>
#include<cmath>     // for the math functions

using namespace std;

//function declaration or function prototype - placed outside main

//This function will find one root of a quadratic equation
double findRoot(double a, double b, double c);

int main()
{
    int size;
    cout<<"Enter the letter size: ";
    cin>>size;
    /* Print H
    * For the H, we see some space between teh 2 stems. We have to put the
    * spaces in there ourselves. The *'s will not be automatically spaced out.
    * As usual, we complete one row before moving on to the next.
    *
    *   0  *   *
    *   1  *   *
    *   2  *****
    *   3  *   *
    *   4  *   *
    *
    *   5/2 => 2. 7/2 => 3. 9/2 =>4  middle row -> size/2
    *   If size =5, 3 space. IF size=7, 5 space. If size=9, 7 spaces. Number of sapce => size-2
    *
    *   middle row -> row full of *
    *   any other row -> *, then size-2 spaces, then *
    */
    cout<<"\nPrinting H\n";
    for(int r=0; r<size; r++)
    {
        if( r == size/2)    // middle row
        {
            for(int c=0; c<size; c++)
                cout<<"*";
        } else
        {
            cout<<"*";
            for(int c=0; c<size-2; c++)
                cout<<" ";
            cout<<"*";
        }
        cout<<endl;
    }

    /* Printing N
     *
     *      *     *     row 0: * 5 spaces *
     *      **    *     row 1: * 0 spaces * 4 spaces *
     *      * *   *     row 2: * 1 space * 3 spaces *
     *      *  *  *     row 3: * 2 spaces * 2 spaces *
     *      *   * *     row 4: * 3 spaces * 1 space *
     *      *    **     row 5: * 4 spaces * 0 spaces *
     *      *     *     row 6: * 5 spaces *
     *
     * 1. Every row has 1 star on 0th column
     * 2a. If ist or last row, print size-2spaces
     * 2.b: Otherwise, these rows need spaces, * more spaces
     *      2.b.1: Print (row-1) spaces
     *      2.b.2: Print *
     *      2.b.3: size - 2 (stem *), -1 (middle *) - (row-1)
     *              = size -2 -1 -row +1 = size - row -2
     *              Print (size -row-2) spaces
     * 3. Every row needs * at the last column, followed by newline
     */

    cout<<"\nPrinting N\n";
    for(int r=0; r<size; r++)
    {
        cout<<"*";
        if( r== 0 || r==size-1)
        {
            for(int c=0; c<size-2; c++)
                cout<<" ";
        } else
        {
            for(int c=0; c<r-1; c++)
                cout<<" ";
            cout<<"*";
            for(int c=0; c<size -r -2; c++)
                cout<<" ";
        }
        cout<<"*"<<endl;
    }

    /* Using some cmath functions
     * We can either directly print the value returned by a function or store
     * it in a variable and then use it later
     *
     * Square roots
     * The function sqrt returns the square root of a number.
     *
     * Rasing a number to an exponent
     * The function pow raises a number to an exponent
     *
     * Trigonometric functions
     * cmath offers a range of trigonometric functions including sin, cos, tan, etc
     * They assume the given angle is in radians
     *
     */
    double num, exp, ans1;
    cout<<"Enter a number: ";
    cin>>num;
    cout<<"Enter the exponent: ";
    cin>>exp;
    ans1 = sqrt (num);      // call the sqrt funtion to get the square root
    cout<<"The square root of "<<num<<" is "<<ans1<<endl;

    double ans2 = pow (num, exp);   // call pow to raise num to exp'th power
    cout<<num<<" raised to "<<exp<<" is "<< ans2<<endl;

    double rad = num * 3.14159 / 180;   // convert num from degrees to radians
    cout<<"sine of "<<num<< " is "<<sin(rad)<<endl; // function calls can be in couts too

    /* Here, we demonstrate the trigonometric functions.
	 * They take the value of the angle in radians.
	 * We loop on the user choosing from a menu of options
	 * the loop runs, asking for the angle and trigonometric function
	 * every time.
     */
    double angle;
    char option;

    do
    {
        cout<<"Enter the angle :";
        cin>>angle;

        cout<<"S - Sine\nC - Cosine\nT- Tangent\nE- Exit\nEnter your choice: ";
        cin>>option;

        switch(option)
        {
            case 'S': cout<< sin(angle);
                break;
            case 'C': cout<<cos(angle);
                break;
            case 'T': cout<<tan(angle);
                break;
            case 'E': cout<<"Bye!";
                break;
            default: cout<<"Invalid option";
        }

      }while(option != 'E'); //keep going as long as the user doesn't exit

    //Calling the findRoot function
    double x2, x, one, root;
    cout<<"Enter the coefficients of x^2, x ad 1: ";
    cin>>x2>>x>>one;

    root = findRoot(x2, x, one);     // function call
    //parameters here - actual parameters

    cout<<"The larger root is "<<root<<endl;

    return 0;
}

//function definitions go below main

/* Function to find the larger root of a quadratic equation
 * y = ax^2 + bx + c
 * Parameters: 3 - a,b,c - double
 * Return - larger root of the equation - double
 * (-b +/- square root ( b^2 - 4ac)) / (2a)
 */

// parameters here - formal parameters
double findRoot(double a, double b, double c) //a,b,c also to findRoot
{
    double ans;     // ans also local to findRoot
    ans = (-b + sqrt ( b*b - 4*a*c)) / (2*a);
    a = 45;
    cout<<"In findRoot, a = "<<a<<endl;
    return ans;
}