Mathematics 1201: Programming in C
		Solutions to Homework Assignment #7
			Prof. Wickerhauser

Exercise 4, Chapter 7, p. 178.
  Program:
    #include <stdio.h>
    #define MaxDegree 100
    typedef double Polynomial[ MaxDegree ];	/* degree 99 or less */
    void Add ( Polynomial Left, Polynomial Right, Polynomial Sum )
    {
      int i;
      for( i=0; i<MaxDegree; i++ )    Sum[i] = Left[i] + Right[i];
      return;
    }
    void Print ( Polynomial Left )
    {
      int i, degree;

      /* Find the degree of the polynomial. */
      degree = -1;	/* signifies the 0 polynomial, a special case */
      for( i=0; i<MaxDegree; i++ )
	if ( Left[i] != 0 ) degree = i; /* holds index of last nonzero coef. */

      /* Print the polynomial, highest degree term first: */
      if ( degree == -1 )	/* the 0 polynomial, a special case */
	printf( " P[x] is the zero polynomial.\n" );
      else {			/* print the terms, 4 per line */
	int countdown;
	printf( "P[x] = " );
	for( i=degree, countdown=4; i>0; i-- ) {
	  printf( " (%f)x^%d +", Left[i], i );
	  if ( !--countdown ) {
	    printf("\n");
	    countdown = 4;
	  }
	}
	printf( " (%f).\n", Left[0] ); /* Last, constant term */
      }
      return;
    }
    main ( void )
    {
      Polynomial a={1,0,3,4,5,5,6}, b={2,-12,0,0,0,0,-3,0,4}, c;
      int i;

      Print(a);
      Print(b);
      Add(a,b,c);
      Print(c);
      return 0;
    }
  Output:
    % a.out      
    P[x] =  (6.000000)x^6 + (5.000000)x^5 + (5.000000)x^4 + (4.000000)x^3 +
     (3.000000)x^2 + (0.000000)x^1 + (1.000000).
    P[x] =  (4.000000)x^8 + (0.000000)x^7 + (-3.000000)x^6 + (0.000000)x^5 +
     (0.000000)x^4 + (0.000000)x^3 + (0.000000)x^2 + (-12.000000)x^1 +
     (2.000000).
    P[x] =  (4.000000)x^8 + (0.000000)x^7 + (3.000000)x^6 + (5.000000)x^5 +
     (5.000000)x^4 + (4.000000)x^3 + (3.000000)x^2 + (-12.000000)x^1 +
     (3.000000).

Exercise 9, Chapter 7, p. 178:
  Program:
    /* Reuse the function `Swap() from Chapter 6, exercise 1: */
    void Swap( int *p1, int *p2)
    {
      int tmp;
      tmp = *p1;
      *p1 = *p2;
      *p2 = tmp;
      return;
    }
    /* Print the integers in a named array, separated by spaces: */
    #include <stdio.h>
    void PrintArray( int *A, unsigned int N, const char *Name )
    {
      int i;
      printf("%s =", Name);
      for ( i=0; i<N; i++ ) printf(" %d", A[i]);
      putchar('\n');
      return;
    }
    void Reverse ( int *A, unsigned int N )
    {
      int i;
      int *lo, *hi;
      lo = A;
      hi = A+N;
      for( i=0; i<N/2; i++)   Swap ( lo++ , --hi );
      return;
    }
    main(void)
    {
      int a[10] = {0,1,2,3,4,5,6,7,8,9};	/* even number of elements */
      int b[9] = {0,1,2,3,4,5,6,7,8};	/* odd number of elements */
      PrintArray(a, 10, "Original a[]");
      Reverse( a, 10 );
      PrintArray(a, 10, "Reversed a[]");
      PrintArray(b, 9, "Original b[]");
      Reverse( b,9 );
      PrintArray(b, 9, "Reversed b[]");
      return 0;
    }

  Output:
    % a.out      
    Original a[] = 0 1 2 3 4 5 6 7 8 9
    Reversed a[] = 9 8 7 6 5 4 3 2 1 0
    Original b[] = 0 1 2 3 4 5 6 7 8
    Reversed b[] = 8 7 6 5 4 3 2 1 0


Exercise 10 of Chapter 7, p. 179.
  The following behavior is called for in the ANSI C standard:

  (a) When Original is NULL, realloc(Original, NewBytes) should return a
	pointer to a fresh array of NewBytes bytes with undefined contents,
	unless it is impossible to allocate that much memory, in which case
	the return value is NULL.
	[my system does this correctly]

  (b) When NewBytes is 0, if Original is non-NULL it should be freed and NULL
	returned; if Original is NULL, realloc(Original,Newbytes) should do
	nothing other than return a NULL pointer.
	[my system does this correctly.]

Exercise 17, Chapter 7, p. 179

  Program:
    int
    Max1( const int A[], unsigned int N ) {
      int maximum;
      unsigned int i;
      maximum = A[0];
      for( i=1; i<N; i++)
	if ( maximum<A[i] ) maximum = A[i];
      return maximum;
    }
    int
    Max2( const int *A, unsigned int N ) {
      int maximum;
      maximum = *A++;
      while( --N ) {
	if ( maximum<*A ) maximum = *A;
	++A;
      }
      return maximum;
    }
    #include <stdio.h>
    #include <stdlib.h>
    #define LENGTH (1<<20)		/* big, i.e., 1<<20 */
    void
    usage(char *program_name)
    {
      printf("Usage: %s x; x=1 for Max1() and x=2 for Max2().\n", program_name);
      exit(1);
    }
    int
    main(int argc, char **argv)
    {
      int i, max, *a;
      if(argc!=2) usage(argv[0]);
      /* Allocate `a[]' and fill it with a few numbers: */
      a = (int *)calloc(LENGTH, sizeof(int));
      switch( *argv[1] ) {
	case '1':
	  max = Max1(a,LENGTH);
	  break;
	case '2':
	  max = Max2(a,LENGTH);
	  break;
	default:
	  usage(argv[0]);
	}
      printf("Max%c: %d\n", *argv[1], max);
      return(0);
    }

  Output:

   Optimized:
    % cc -O ch7ex17.c
    % time a.out 2        ==> 0.6 seconds
    % time a.out 1        ==> 0.6 seconds

   Not optimized:
    % cc ch7ex17.c   
    % time a.out 1        ==> 1.3 seconds
    % time a.out 2        ==> 0.9 seconds