/** Val.h
 *  J Scott Cameron
 *  
 *  defines Value class to be used as 
 *  parameters in Genetic Images functions
 *  
 *  each Val holds a triplet that is used
 *  as an RGB value
 */
#include <math.h>

/* varaible for mutation */
static float g_mutate = .1f ;



class Val{
	
public:

	/* red/green/blue values */
	double r,g,b;
	
	/* parameterized contructor */
	Val(double red, double green, double blue) 
	{
		r= red;
		g=green;
		b=blue;
	}
	
	/* default Constructor (black) */
	Val() 
	{
		r= 0;
		g=0;
		b=0;
	}
	
	/* overload of addition operator */
	Val operator+(Val a)
	{
		return Val(a.r+r,a.g+g,a.b+b);
	}
	
	/* overload of subtraction operator */
	Val operator-(Val a)
	{
		return Val(r-a.r,g-a.g,b-a.b);
	}
	
	/* overload of multiplication operator */
	Val operator*(Val a)
	{
		return Val(r*a.r,g*a.g,b*a.b);
	}
	
	/* overlaod of division operator */
	Val operator/(Val a)
	{
		double dr = a.r, dg=a.g,db=a.b;
		if(dr == 0) dr = 1.0;
		
		if(dg == 0) dg = 1.0;
		
		if(db == 0) db = 1.0;
		
		return Val(r/dr,g/dg,b/db);
	}
	
	/* overload of modulo operator */
	Val operator%(Val a)
	{
		long dr = (long)a.r, dg=(long)a.g,db=(long)a.b;
		if(dr == 0) dr = 1;
		if(dg == 0) dg = 1;
		if(db == 0) db = 1;
		
		
		
		return Val((long)r%(long)dr,(long)g%(long)dg,(long)b%(long)db);
	}
	
	/* overload of greater than operator */
	Val operator>(Val a)
	{
		double nr=0.0,ng=0.0,nb=0.0;
		if(r > a.r) nr = 1.0;
		if(g > a.g) ng = 1.0;
		if(b > a.b) nb = 1.0;
		
		return Val(nr,ng,nb);
	}
	
	/* overload of lesser than operator */
	Val operator<(Val a)
	{
		double nr=0.0,ng=0.0,nb=0.0;
		if(r < a.r) nr = 1.0;
		if(g < a.g) ng = 1.0;
		if(b < a.b) nb = 1.0;
		
		return Val(nr,ng,nb);
	}
	
	/* overload of negation operator */
	Val operator-()
	{
		return Val(-r,-g,-b);
	}
	
	/* overload of copy operator */
	Val operator=(double a)
	{
		return Val(a,a,a);
	}
	
    /* another overload of copy operator */
	Val operator=(int a)
	{
		return Val(a,a,a);
	}
	
	/* overlaod of multiplication operator */
	Val operator*(double a)
	{
		return Val(r*a,g*a,b*a);
	}
	
	/* overload of division operator */
	Val operator/(double a)
	{
		return Val(r/a,g/a,b/a);
	}
	
	
	/* returns the max of r/g/b */
	double maximum()
	{
		if((r > g) && (r > b))
			return r;
		else if(g > b)
			return g;
		return b;
	}
	
	/* returns the minimum of r/g/b */
	double minimum()
	{
		if((r < g) && (r < b))
			return r;
		else if(g < b)
			return g;
		return b;
	}
	
};