// Example program 26
// This program calculates Income tax
// by looking at a tax table.


#include <iostream.h>
int main()
{
   double tax(int);
   int taxable_income;
   cout << "Enter your taxable income:"<<endl;
   cin >> taxable_income;

   if(taxable_income > 200 || taxable_income <0)
     cout << "Can't find your tax from the given table"<<endl;
   else
     cout << "Your tax is "<< tax(taxable_income)
	  <<" dollars" << endl;
return 0;
}

double tax(int income)
{
 int income_table[11]={0,5,15,25,50,75,100,125,150,175,200};
 double tax_table[11]={0,2,3,6,9,13,17,21,24,28,32};

 int i;
 i = 0;
 while (i < 11 && income >= income_table[i])
     ++ i;

     -- i;
 return tax_table[i];
 }




// Example program 27
// This program calculates the largest among
// a set of real numbers.


#include <fstream.h>
int main()
{
  double max(double[], int);
  int i,number;
  double real_number[50];
  cout <<"How many real numbers "
       <<"you would like to enter [1-50]?"<<endl;
  cin >> number;

  cout <<"Please enter "<<number
       <<" real numbers"<<endl;

  for(i=0; i < number; ++ i)
     cin >> real_number[i];

  cout <<"The largest real number is "
       <<max(real_number,number)<<endl;
  return 0;
}

double max(double x[], int n)
{
  int k;
  double largest;
  largest = x[0];
  for (k = 0; k < n; ++ k)
    if (x[k] > largest)
      largest = x[k];
  return largest;
}




// Example program 28
// This program calculates the shipping charges for
// mail orders based on price and sales region.
// The program uses the region number to access
// the array elements.

#include <iostream.h>
void main()
{
  double rate[5] = {0.075,0.080,0.085,0.088,0.090};
  int region;
  double price, charge, total_price;

  cout <<"Enter the price of the item: $";
  cin >> price;
  cout<<endl<<"Enter the shipping region (1-5): ";
  cin >> region;

  if (region < 1 || region > 5)
     cout <<"\n\n*** Invalid region number ***";
  else
     {
       charge = price * rate[region - 1];
       total_price = price + charge;
       cout <<"\n\nItem Price:  "<<price;
       cout <<"\nShipping Charge:  "<<charge;
       cout <<"\nTotal Price:  "<<total_price;
     }
}




// Example program 29
// This program produces the weekly payroll for a
// small business. For each hourly employee, the
// program reads the employee id, the number of
// hours worked, and the pay rate for the employee.
// The program validates the pay rate as it reads.
// The only valid pay rates are the following:
// 5.00, 5.50, 5.75, 6.25, 6.50,7.00,7.25,7.50.
// The overtime pay is to calculated at the rate of
// 1.5 times the normal rate for hours an employee
// worked over 40. The program outputs the employee
// id, the regular pay, overtime pay, and gross pay
// for that employee. At the end, the program also
// outputs the number of employees it processed, and
// total payroll, that is the sum of the gross
// salaries of the employees.
#include <fstream.h>
void main()
{
  int valid(double);
  int emp_id, emp_hours;
  double emp_rate;
  double reg_pay,ovt_pay,gross_pay;
  int no_emps=0;
  double tot_pay=0.0;

  ifstream infile;
  ofstream outfile;
  infile.open("ex30.in");
  outfile.open("ex30.out");

  infile >> emp_id >> emp_hours >> emp_rate;
  // Print heading
  outfile <<"Employee   Regular    Overtime    Gross"<<endl;
  outfile <<"   ID        Pay         Pay       Pay"<<endl;
  outfile <<"---------------------------------------"<<endl;
  while(infile)
  {
    ++no_emps;
    if (valid(emp_rate))
    {
       if(emp_hours <=40)
       {
	 reg_pay = emp_hours*emp_rate;
	 ovt_pay = 0.0;
       }
       else
       {
	  reg_pay=40*emp_rate;
	  ovt_pay=1.5*emp_rate*(emp_hours-40);
       }
       gross_pay=reg_pay+ovt_pay;
       tot_pay = tot_pay + gross_pay;
       outfile <<"   "<<emp_id <<"      "
	       <<reg_pay<<"          "
	       <<ovt_pay<<"        "
	       <<gross_pay<<endl;
     }
     else
       outfile <<"   "<<emp_id
               <<"  *** Invalid Pay Rate ***"<<endl;
     infile >> emp_id >> emp_hours >> emp_rate;
  }
 outfile<<"---------------------------------------"<<endl;
 outfile<<"Number of employees: "<<no_emps<<endl;
 outfile<<"Total payroll: "<<tot_pay<<endl;
}
int valid(double emp_rate)
{
  double rate_table[8]=
  {5.00,5.50,5.75,6.25,6.50,7.00,7.25,7.50};

  int i;
  for(i=0; i < 8; ++ i)
    if(emp_rate == rate_table[i]) break;

  if (i < 8)
     return 1;
  return 0;
}


// Example Program 30
// This program calculates the total commission of a
// salesperson according to the following rate:
//          Quarter 1:   Commission = 3% of sales amount
///          Quarter 2:   Commission = 4.5% of sales amount
//           Quarter 3:   Commission = 3.5% of sales amount
//           Quarter 4:   Commission = 4% of sales amount
// Total commission is the summation of commissions
// received in all four quarters by a salesperson.

// Input: Salesperson Id, last name, first name,
// sales amounts for all four quarters for each
// salesperson

// Output: Salesperson Id, name, and total commission
//  for each salesperson. Output should be sorted by
//  total commission in descending order.

struct sales_rec {
    int  id;             // salesperson id
    char lname[11];      // last name of salesperson
    char fname[11];      // first name of salesperson
    double sales[4];     // sales figures for four quarters
    double comm;         // commission to be calculated
    };
const int SIZE = 5;
#include <fstream.h>
#include <string.h>
#include <iomanip.h>

void main()
{
  sales_rec salesperson[SIZE];    // structure array

  // function prototypes
  void read_data(sales_rec [], int&);
  void calc_comm (sales_rec [], int);
  void sort (sales_rec [], int);
  void write_results(sales_rec [], int);

  int number;          // number of salespeople's records
	         // found in input file

  read_data(salesperson, number);
  calc_comm(salesperson, number);
  sort (salesperson, number);
  write_results(salesperson, number);

  return;

}


//--------------------------------------------------------
void read_data(sales_rec x[], int& n)
{
  ifstream infile;
  infile.open("sales.in");
  int i, j;
  i = 0;
  while (infile && i < SIZE)  // Don't exceed array size
  {
    infile >> x[i].id >> x[i].lname >> x[i].fname;
    for (j = 0 ; j < 4; ++ j)
       infile >> x[i].sales[j];
    ++ i;
   }

   n = i-1;
   infile.close();
   return;
}

//---------------------------------------------------
// Calculate total commission
void calc_comm (sales_rec sp[ ], int n)
{
  // Commission rates for quarters 1, 2, 3, and 4
  double rate[4] = {0.03, 0.045, 0.035, 0.04};
  int i, j;

  for (i = 0; i < n; ++ i)
  {
    sp[i].comm = 0;
    for (j = 0; j < 4; ++j)
       sp[i].comm = sp[i].comm + sp[i].sales[j]*rate[j];

  }
  return;
}

//--------------------------------------------------------
// Sorts in descending order
void sort(sales_rec sp[], int n)
{
  // temporary structure for swaping use
  sales_rec  temp;
  int pass, i, limit;

  // do bubble sort
  limit = n - 2;
  for (pass = 1; pass < n; ++ pass)
    {
       for (i = 0; i <= limit; ++ i)
	 if (sp[i].comm < sp[i+1].comm)
	   { // swap
	     temp = sp[i];
	     sp[i] = sp[i+1];
	     sp[i+1] = temp;
	   }
       -- limit;
    }
  return;
}


//-----------------------------------------------------
void write_results(sales_rec sp[], int n)
{
  int i;
  ofstream outfile;

  char name[21];
  outfile.open("sales.out");

  // turn on manipulators
  outfile.setf(ios::fixed, ios::floatfield);
  outfile.setf(ios::showpoint);

  outfile<< setprecision(2);

  // write heading
  outfile <<"Salesperson ID    "
	  <<"Salesperson Name     "
	  <<"Commission"<<endl;
  for (i = 0; i < 50; ++ i)
     outfile <<'-';
  outfile <<endl;

  for (i = 0; i < n; ++ i)
  {
    outfile <<"    "<< sp[i].id <<"   ";  // write id

    strcpy(name, sp[i].fname);       // copy first name
    strcat(name, " ");               // copy space
    strcat(name, sp[i].lname);       // copy last name
    outfile <<"        "<< name <<"   ";          // write name
    outfile << setw(20 - strlen(name) + 8)<<
	    sp[i].comm << endl;   // write commission
  }
  outfile.close();
  return;
}