/* This program demonstrates
 * 1. Reading and printing array values
 * 2. Copying arrays - deep copy required
 * 3. Working with array elements as L-values and R-values
 * 4. Working with arrays and functions.
 *
 * Arrays can be passed into function like regular variables.
 * However, arrays always pass by reference. So any changes made to the array
 * in the function will be preserved across the function call and will be refected
 * in main, or any other calling function.
 */

#include<iostream>
#include<cmath>
using namespace std;

/* Declare the functions here
 * when we pass an array into the function, we don't have to mention the size
 * the array. Mentioning it won't result in an error, but it is not necessary.
 * However, we have to specify it is an array, by using the []
 *
 * Function names are self-descriptive here. They are described while being defined.
 */
void cubeElements(double arr[], int numElements);

int linearSearch(double arr[], int size, double key);

void leftArrayShift(double arr[], int size);

int main()
{
    double arr[10];     // declare the array

    //accept array values from the user
    cout<<"\nEnter values for the array: ";
    for(int i=0; i<10; i++)
    {
        cin>>arr[i];
    }

    cout<<"Printing array values: ";
    for(int i=0; i< 10; i++)
    {
        cout<< arr[i]<<"\t";
    }

    double sum =0;

    /* We can perform all the operations we've seen so far using array
     * elements as variables
     * For example, to get the sum of all array elements
     * iterate through the array, add each value to the sum
     */
    for(int i=0; i<10; i++)
    {
        sum = sum + arr[i];
    }

    // Replace array elements with the rounded down square roots of new numbers.

    for(int i=0; i<10; i++)
    {
       arr[i] = static_cast<int> ( sqrt ( abs (arr[i] ) ) );
    }

    cout<<"Elements replaced by rounded down square roots: ";
    for(int i=0; i<10; i++)
    {
        cout<<arr[i]<<"\t";
    }
    cout<<endl;

    cout<<"The sum of the old elements in the array: "<<sum<<endl;

    /* Unlike individual variables, we cannot use the assignment operator =
   * to copy one array onto another. Instead, we would have to iterate
   * through the array and copy out each individual element. This is called
   * a deep copy of the array
   */

    const int NUM = 10;
    double copyArr[NUM];
    //deep copy
    for(int i=0; i<NUM; i++) {
        copyArr[i] = arr[i];
        cout << "Copy[" << i << "]: " << copyArr[i] << endl;
    }

    /* calling the cubeElements function. Note that when we call the
    * function, we only mention the name of the array.
    */

    cubeElements(copyArr, NUM);

    /* You will notice that changing the values of array elements in the
    * cubeElements function has resulted in squaring the values of the
    * array in the main function as well. This is because arrays always pass
    * by address (which resembles pass by reference), even without us
     * explicitly saying anything */
    cout<<"After function call: ";
    for(int i=0; i<NUM; i++)
        cout<<copyArr[i]<<"\t";
    cout<<endl;

    double searchVal;
    int foundPos;
    cout<<"Enter the search value: ";
    cin>>searchVal;

    //call the function, store the returned value in "found"
    foundPos = linearSearch(arr, NUM, searchVal);

    if( foundPos == -1)
        cout<<"The element is not in the array"<<endl;
    else cout<<"The element was found in position "<<foundPos<<endl; 
    
    leftArrayShift(arr, NUM);
    cout<<"\nAfter right shift:\n";
    for(int i=0; i< 10; i++)
    {
        cout<< arr[i]<<"\t";
    }
    return 0;
}

/* Function cubeeElements - 2 parameters, returns nothing
 * iterates through the array and cubes the individual elements
 *
 * This function serves to demonstrate that arrays automatically pass by reference
 * We square each array element and put it back in the same place.
 */
void squareElements( double arr[], int size)
{
    for(int i=0; i<size; i++)
    {
        arr[i] = pow(arr[i],3);
    }
}

/* function linearSearch
 * parameters - array, size, and search value
 * returns - position where search value was found
 *
 * 12 8 19 -6 7, size = 5, search value = 19
 * Ans: return position 2
 *
 * Move through the array
 * Compare value in current index to search key
 *    if found, mark position
 *  If element not found, return an impossible index
 */
int linearSearch(double arr[], int size, double key)
{
    int pos = -1;   // impossibe index for an element to be found in
    for(int i=0; i<size; i++)
    {
        if( arr[i] == key)
        {
            pos = i;
        }
    }
    return pos;
}

/* function leftShift
 * parameters - array and its size
 * returns nothing
 *
 * Moves array elements one spot to the left
 * start at the beginning, N-1 moves
 *
 * element in index 1 moves to index 0
 * element in index 2 moves to index 1
 * elements in index 3 moves to index 2
 *
 * element in index i+1 moves to index i
 * place a 0 in the last index
 */
void leftArrayShift(double arr[], int size)
{
    for(int i=0; i<size -1; i++)
    {
        arr[i] = arr[i+1];
    }
    arr[size-1] = 0;
}