/*
 * targets.cc -- Lithium Genetic Programming Toolkit -- TargetNumbers for evolution targets
 *
 # Copyright (c) 2006 Henry Strickland -- <strick> in the domain <yak.net>
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),
 # to deal in the Software without restriction, including without limitation
 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
 # and/or sell copies of the Software, and to permit persons to whom the
 # Software is furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 # OTHER DEALINGS IN THE SOFTWARE.
 #
 #         (* http://www.opensource.org/licenses/mit-license.php *)
 *
 */
 
#include "li.h"

namespace Li {

static Numbers* FindTargNums(const char* targName)
{
     return dynamic_cast<TargetNumbers*>(Target::Find(targName))->numbers;
}

struct TargetNumbers_Xxxxx : public TargetNumbers {
	TargetNumbers_Xxxxx() : TargetNumbers("xxxxx") {
		for (int i=0; i<256; i++) {
			numbers->vec.push_back( 'x' );
		}
	}
} TargetNumbers_Xxxxx_Singleton;
TEST(targ_Xxxxx) { AssertEq( 'x', FindTargNums("xxxxx")->vec.at(255) ); }

struct TargetNumbers_Ones : public TargetNumbers {
	TargetNumbers_Ones() : TargetNumbers("ones") {
		for (int i=0; i<256; i++) {
			numbers->vec.push_back(i);
		}
	}
} TargetNumbers_Ones_Singleton;
TEST(targ_Ones) { AssertEq( 255, FindTargNums("ones")->vec.at(255) ); }

struct TargetNumbers_Twos : public TargetNumbers {
	TargetNumbers_Twos() : TargetNumbers("twos") {
		for (int i=0; i<256; i++) {
			numbers->vec.push_back( i*2 );
		}
	}
} TargetNumbers_Twos_Singleton;
TEST(targ_Twos) { AssertEq( 255*2, FindTargNums("twos")->vec.at(255) ); }

struct TargetNumbers_Sevens : public TargetNumbers {
	TargetNumbers_Sevens() : TargetNumbers("sevens") {
		for (int i=0; i<256; i++) {
			numbers->vec.push_back(i*7);
		}
	}
} TargetNumbers_Sevens_Singleton;
TEST(targ_Sevens) { AssertEq( 255*7, FindTargNums("sevens")->vec.at(255) ); }


struct TargetNumbers_Saw23 : public TargetNumbers {
	TargetNumbers_Saw23() : TargetNumbers("saw23") {
		for (int i=0; i<256; i++) {
			numbers->vec.push_back( 1 + i%23 );
		}
	}
} TargetNumbers_Saw23_Singleton;
TEST(targ_Saw23_22) { AssertEq( 23, FindTargNums("saw23")->vec.at(22) ); }
TEST(targ_Saw23_23) { AssertEq( 1, FindTargNums("saw23")->vec.at(23) ); }

struct TargetNumbers_Ramps : public TargetNumbers {
	TargetNumbers_Ramps() : TargetNumbers("ramps") {
		for (int i=0; i<256; i++) {
			for (int j=i; j>0; j--) {
				numbers->vec.push_back( j );
				if ( numbers->vec.size() == 256 ) return;
			}
		}
	}
} TargetNumbers_Ramps;
TEST(targ_Ramps_3) { AssertEq( 3, FindTargNums("ramps")->vec.at(3) ); }
TEST(targ_Ramps_2) { AssertEq( 2, FindTargNums("ramps")->vec.at(4) ); }
TEST(targ_Ramps_1) { AssertEq( 1, FindTargNums("ramps")->vec.at(5) ); }

struct TargetNumbers_Triangle : public TargetNumbers {
	TargetNumbers_Triangle() : TargetNumbers("tri") {
		int sum= 0;
		for (int i=0; i<256; i++) {
			sum += i;
			numbers->vec.push_back(sum);
		}
	}
} TargetNumbers_Triangle_Singleton;
TEST(targ_Triangle) { AssertEq( (255*256)/2 , FindTargNums("tri")->vec.at(255) ); }


struct TargetNumbers_Roman1 : public TargetNumbers {
	TargetNumbers_Roman1() : TargetNumbers("roman1") {
		for (int i=1; true; i++) {
			for (int j=0; j<i; j++) {
				numbers->vec.push_back(1);
				if (numbers->vec.size() == 256) break;
			}
			if (numbers->vec.size() == 256) break;
			numbers->vec.push_back(0);
			if (numbers->vec.size() == 256) break;
		}
	}
} TargetNumbers_Roman1_Singleton;
TEST(targ_Roman1_6) { AssertEq( 1, FindTargNums("roman1")->vec.at(6) ); }
TEST(targ_Roman1_7) { AssertEq( 1, FindTargNums("roman1")->vec.at(7) ); }
TEST(targ_Roman1_8) { AssertEq( 0, FindTargNums("roman1")->vec.at(8) ); }
TEST(targ_Roman1_9) { AssertEq( 1, FindTargNums("roman1")->vec.at(9) ); }
TEST(targ_Roman1_10) { AssertEq( 1, FindTargNums("roman1")->vec.at(10) ); }

struct TargetNumbers_Roman5 : public TargetNumbers {
	TargetNumbers_Roman5() : TargetNumbers("roman5") {
		for (int i=1; true; i++) {
			for (int j=i; j>0; ) {
				if (j>=5) {
					numbers->vec.push_back(5);
					j -= 5;
				} else {
					numbers->vec.push_back(1);
					j -= 1;
				}
				if (numbers->vec.size() == 256) break;
			}
			if (numbers->vec.size() == 256) break;
			numbers->vec.push_back(0);
			if (numbers->vec.size() == 256) break;
		}
	}
} TargetNumbers_Roman5_Singleton;


struct TargetNumbers_Fibonacci : public TargetNumbers {
	TargetNumbers_Fibonacci() : TargetNumbers("fib") {
		int a= 0;
		int b= 1;
		numbers->vec.push_back(0);
		for (int i=0; i<255; i++) {
			int sum= a+b;
			numbers->vec.push_back(sum);
			a=b;
			b=sum;
		}
	}
} TargetNumbers_Fibonacci_Singleton;
TEST(targ_Fibonacci) { AssertEq( 13, FindTargNums("fib")->vec.at(6) ); }

struct TargetNumbers_Fibo20 : public TargetNumbers {
	TargetNumbers_Fibo20() : TargetNumbers("fib20") {
		int a= 0;
		int b= 1;
		numbers->vec.push_back(0);
		for (int i=0; i<19; i++) {
			int sum= a+b;
			numbers->vec.push_back(sum);
			a=b;
			b=sum;
		}
	}
} TargetNumbers_Fibo20_Singleton;
TEST(targ_Fibo20) { AssertEq( 13, FindTargNums("fib20")->vec.at(6) ); }

struct TargetNumbers_Fibo33 : public TargetNumbers {
	TargetNumbers_Fibo33() : TargetNumbers("fib33") {
		int a= 0;
		int b= 1;
		numbers->vec.push_back(0);
		for (int i=0; i<32; i++) {
			int sum= a+b;
			numbers->vec.push_back(sum);
			a=b;
			b=sum;
		}
	}
} TargetNumbers_Fibo33_Singleton;
TEST(targ_Fibo33) { AssertEq( 13, FindTargNums("fib33")->vec.at(6) ); }

struct TargetNumbers_Stair122333 : public TargetNumbers {
	TargetNumbers_Stair122333() : TargetNumbers("stair122333") {
		for (int i=0; i<999; i++) {
			for (int j=0; j<i; j++) {
				numbers->vec.push_back(i);
				if ( numbers->vec.size() == 256 ) return;
			}
		}
	}
} TargetNumbers_Stair122333_Singleton;
TEST(targ_Stair122333_at5) { AssertEq( 3, FindTargNums("stair122333")->vec.at(5) ); }
TEST(targ_Stair122333_at6) { AssertEq( 4, FindTargNums("stair122333")->vec.at(6) ); }

}//Li