/*                  CSC 16 Notes

    Java is a language that allows for several styles of programming. 

    You already know about the recursive versus non-recursive style.
    Many functions, such as binary search, can be written with or
    without recursion and the question as to which style is better is
    debatable.  However, there are also examples, such as quicksort,
    were recursion offers a clear advantage over the "iterative" style
    of programming which relies only on loops.
    
    In this program, I will contrast two further sets of styles, these being:

    1. object-oriented versus functional style

    2. Constructive versus destructive style


    We first discuss object-oriented (oop) versus functional:

    In the oop style, function calls are made as in

       myaccount.withdraw(100);

    Where withdraw is defined as:

    class account 
    { double balance; 
      ...
      public void withdraw(double amount)
      {  this.balance -= amount; }
      ...
    }

    That is, the object to the left of the "." determines the context of the call.
    Within the body of the function, "this" refers to the object that the function was
    invoked on.

    The functional style of programming, on the other hand, relies solely on static
    functions.  For these functions, all data relevant to the processing of information
    are either passed in as variables, or are themselves also static information.

    That is, if we wrote the withdraw method of the simple bank account class as follows:

    public static void withdraw(account A, double amount)
    {
      A.balance -= amount
    }    

    Then it would be in the functional style, and will have to be invoked in the 
    following way:

    account.withdraw(myaccount,100);

    The name to the left of the "." is now the name of the CLASS, because the
    function is now independent of any instance of the class. This style of programming
    is also valid, and is in fact better for many recursive algorithms.
    //////

    The second constrast in styles is between constructive and destructive programming:
    Constructive means we create new a structure, and destructive means we modify an 
    existing structure.  Suppose we want to write a procedure that adds one to every
    number inside an array.  We can either create a new array with a new set of numbers,
    keeping the old array intact (constructive), or change the old array in place
    (destructive):

    // destructive version:
    public void add1(int[] A)
    {
      for(int i=0;i<A.length;i++)  A[i] += 1;
    }
  
    // constructive version:
    public int[] addone(int[] A)
    {
       int[] B = new int[A.length]; // create new array to be returned
       for(int i=0;i<B.length;i++) B[i] = A[i] + 1;
       return B;
    }

    Constructive functions usually return a new structure.  Which one is "better"?
    It depends on if your program still wants to keep the old structure.  In general,
    destructive functions tend to be slightly more efficient but contructive functions
    are more flexible.  For example, you can still replace the old array with the new
    one with:
    
    A = addone(A);   

    For many operations on complex structures, the contructive version will be 
    easier to write.

    The following class further illustrates these constrasts in styles:
*/

class fraction  // class to represent a fraction with numerator N and denominator D
{

    private int N;  // numerator
    private int D;  // denominator
    public fraction(int a, int b) throws Exception
    {
        if (b==0) throw new Exception("denominator can't be zero");
	N = a; D = b;
    }

    public static int gcd(int a, int b)  // compute greatest common divisor
    { if (b==0) return a; else return gcd(b,a%b); }

    // the following function reduces a fraction in the object-oriented style:
    public void reduce()
    {
	int commondiv = gcd(N,D);
	N = N/commondiv;
	D = D/commondiv;
    }
    // implicitly, N is really this.N and D is really this.D

    // Here's the same function, but in the functional style:
    public static void reduce(fraction A)
    {
	int commondiv = gcd(A.N,A.D);
	A.N = A.N/commondiv;
	A.D = A.D/commondiv;
    }
    // this function takes the fraction it needs to reduce as a parameter.

    // Here's another example: determine if two fractions are equal:

    // OOP style:
    public boolean equals(fraction F)
    {
	return N*F.D == D*F.N;
    }

    // functional style:
    public static boolean eq(fraction A, fraction B)
    {  
	return A.N*B.D == B.N*A.D;
    }
    /* Given:
       fraction a = new fraction(1,2);
       fraction b = new fraction(3,6);
       we call the oop version with

               if ( a.equals(b) ) ...

       and we call the functional version with 
 
               if ( fraction.eq(a,b))

       Note also that although N and D are "private", we can still access these
       fields for A and B because they are both objects of the fraction class.
       "private" in Java/C++ is only meaningful at the class level, not at the 
       object level, a fact that many people find unfortunate.
    */


    ////////////////////////////

    /*  The next example shows the difference between the contructive and 
        destructive styles of programming.  Suppose I want to invert the fraction.
        That is, swap the numerator and denominator.  I can do this by either changing
        the object in place, or by creating and returning a new fraction object
        while leaving the original unmodified:
    */

    // destructive invert
    public void invert() throws Exception
    {  
	if (N==0) throw new Exception("can't invert fraction with 0 numerator");
	int temp = N;
	N = D;
	D = temp;
    }

    // constructive invert
    public fraction invertc() throws Exception
    {
	if (N==0) throw new Exception("can't invert fraction with 0 numerator");
        fraction A = new fraction(D,N);
	return A;
    }

    /*
       Sample usage:
       fraction f = new fraction(2,3);
       f.invert();   // f becomes 3/2
       fraction r = f.invertc();  // r becomes 2/3, f is still 3/2


       Notice also that both methods above are in the OOP style.  The issue
       of OOP versus funtional style is orthogonal to the issue of destructive
       versus non-destructive.  That is, it is also possible to write these
       operations in the static/functional style.
    */
  
    // functional, destructive style:
    public static void inv(fraction A) throws Exception
    {  
	if (A.N==0) throw new Exception("can't invert fraction with 0 numerator");
	int temp = A.N;
	A.N = A.D;
	A.D = temp;
    }


    public String toString() { return N+"/"+D; } // is this functional or oop style?

} // fraction



public class styles
{
 public static void main(String[] args)
 {
   try 
   {
      fraction f = new fraction(2,3);
      fraction g = new fraction(4,6);
      if (f.equals(g)) System.out.println("they're equal");
      if (fraction.eq(f,g)) System.out.println("they're still equal");
      f.invert();   // f becomes 3/2 - destructive change
      fraction r = f.invertc();  // r becomes 2/3, f is still 3/2 - constructive style
      System.out.println(r);
      System.out.println(f);
   } catch (Exception e) {System.out.println(e); System.exit(1); }
 } // main
}