ga {

	license: GPL; // BSD, GPL, LGPL or filename of your own license
	language: cpp; //java; // what language to output (cpp, java)
	pass: reference; // or value
	return: value; // or reference
	namespace: c2ga; // what namespace to put the ga in (if any)
	inline: constructors set assign operators functions;// what to inline:
	exception: throw ; // how to handle exceptions: [callback | ignore | throw] 
	
	debug_coordinate_string: disable; //enable or disable
	profile: ; // profiling = disable
//	profile: enable net; 
	
	cpp_operator_default_bindings; // this sets the cpp default operator bindings
	
	//todo: is it always require to register both assign and regular?? 	
	
	multivector_mem_alloc: full; // or parity_pure; memory allocation for general multivector: full or parity pure
	storage: float '%s'; 
	
	basis: no, e1, e2, ni;
	metric: e1 . e1 = e2 . e2 = 1;
	metric: no . ni = -1;
	
	multivector: mv(
			1.0, // grade 0
			no, e1, e2, ni, // grade 1
			no^e1,    no^e2,    e1^e2,    e1^ni,    e2^ni,    no^ni,    // grade 2
			e1^e2^ni, no^e1^ni, no^e2^ni, no^e1^e2, // grade 3
			no ^ e1 ^ e2 ^ ni      // grade 4
		);
	
	specialization: blade no_t(no);
	specialization: blade e1_t(e1);
	specialization: blade e2_t(e2);
	specialization: blade ni_t(ni);
	specialization: blade scalar(1.0);
	
	specialization: blade point(no, e1, e2, ni);
	specialization: blade normalizedPoint(no = 1, e1, e2, ni);
	
	specialization: blade flatPoint(e1^ni, e2^ni, no^ni);
	specialization: blade normalizedFlatPoint(e1^ni, e2^ni, no^ni = 1);
	
	
	specialization: blade pointPair(no^e1,    no^e2,    e1^e2,    e1^ni,    e2^ni,    no^ni);
	specialization: blade TRversorLog(e1^e2,    e1^ni,    e2^ni);
	
	specialization: blade line(e1^e2^ni, e1^no^ni, e2^no^ni);
	specialization: blade dualLine(e1^e2, e1^ni, e2^ni);
		
	specialization: blade circle(e1^e2^ni, no^e1^ni, no^e2^ni, no^e1^e2);
	
	
	specialization: blade freeVector(e1^ni, e2^ni);
	specialization: blade freeBivector(e1^e2^ni);
	
	
	specialization: blade tangentVector(no^e1,    no^e2,    e1^e2,    e1^ni,    e2^ni,    no^ni);
	specialization: blade tangentBivector(e1^e2^ni, no^e1^ni, no^e2^ni, no^e1^e2);
	
	specialization: blade vectorE2GA(e1, e2);
	specialization: blade bivectorE2GA(e1^e2);
	
	specialization: versor TRversor(1.0,  // grade 0
					e1^e2, e1^ni, e2^ni  // grade 2
					);
					
	specialization: versor TRSversor(1.0,  // grade 0
					e1^e2, e1^ni, e2^ni, no^ni,  // grade 2
					e1^e2^no^ni);      // grade 4

	specialization: versor evenVersor(1.0,  // grade 0
		no^e1,    no^e2,    e1^e2,    e1^ni,    e2^ni,    no^ni, // grade 2
		e1^e2^no^ni);      // grade 4
	
	specialization: versor translator(1.0, // grade 0
			e1^ni,    e2^ni    // grade 2
			);
	
	specialization: versor normalizedTranslator(1.0=1, // grade 0
			e1^ni,    e2^ni    // grade 2
			);
	
	specialization: versor rotor(1.0, // grade 0
			e1^e2    // grade 2
			);
	
	specialization: versor scalor(1.0, no ^ ni);
			
	constant: e1ni = "e1 ^ ni"; 
	constant: e2ni = "e2 ^ ni"; 
	constant: noni = "no ^ ni"; 
	constant: I2 = "e1 ^ e2"; 
	constant: I4 = "no ^ e1 ^ e2 ^ ni"; 
	constant: I4i = "::g2bi::inverse(no ^ e1 ^ e2 ^ ni)"; 


	outermorphism: om(
			no, e1, e2, ni, // grade 1
			no^e1,    no^e2,    e1^e2,    e1^ni,    e2^ni,    no^ni,    // grade 2
			e1^e2^ni, no^e1^ni, no^e2^ni, no^e1^e2, // grade 3
			no ^ e1 ^ e2 ^ ni      // grade 4
	);
		
}

mv lcont(mv x, mv y) {
	return ::g2bi::lcont(x, y);
}

mv scp(mv x, mv y) {
	return ::g2bi::scp(x, y);
}

mv gp(mv x, mv y) {
	return x y;
}

mv gpEM(mv x, mv y) {
	return ::g2bi::gp_em(x, y);
}

mv scpEM(mv x, mv y) {
	return ::g2bi::scp_em(x, y);
}

mv lcontEM(mv x, mv y) {
	return ::g2bi::lcont_em(x, y);
}

mv op(mv x, mv y) {
	return x ^ y;
}

mv add(mv x, mv y) {
	return x + y;
}

mv subtract(mv x, mv y) {
	return x - y;
}

scalar norm_e2(mv x) {
	return ::g2bi::scp_em(x, ::g2bi::reverse(x));
}

scalar norm_e(mv x) {
	scalar e2 = ::g2bi::scp_em(x, ::g2bi::reverse(x));
	return ::g2bi::scalar_sqrt(e2);
}

mv unit_e(mv x) {
	scalar e2 = ::g2bi::scp_em(x, ::g2bi::reverse(x));
	scalar ie = ::g2bi::inverse(::g2bi::scalar_sqrt(e2));
	return x ie;
}

scalar norm_r2(mv x) {
	return ::g2bi::scp(x, ::g2bi::reverse(x));
}

scalar norm_r(mv x) {
	scalar r2 = ::g2bi::scp(x, ::g2bi::reverse(x));
	return ::g2bi::scalar_sign(r2) * ::g2bi::scalar_sqrt(::g2bi::scalar_abs(r2));
}

mv unit_r(mv x) {
	scalar r2 = ::g2bi::scp(x, ::g2bi::reverse(x));
	scalar ir = ::g2bi::inverse(::g2bi::scalar_sqrt(::g2bi::scalar_abs(r2)));
	return x ir;
}


mv reverse(mv x) {
	return ::g2bi::reverse(x);
}

mv negate(mv x) {
	return ::g2bi::negate(x);
}

mv dual(mv x) {
	return ::g2bi::dual(x);
}

mv undual(mv x) {
	return ::g2bi::undual(x);
}

mv inverse(mv x) {
	scalar n = ::g2bi::scp(x, ::g2bi::reverse(x));
	scalar in = ::g2bi::inverse(n);
	return ::g2bi::gp(::g2bi::reverse(x), in);
}

mv inverseEM(mv x) {
	scalar n = ::g2bi::scp_em(x, ::g2bi::reverse(x));
	scalar in = ::g2bi::inverse(n);
	return ::g2bi::gp_em(::g2bi::reverse(x), in);
}


mv apply_om(om x, mv y) {
	return x * y;
}

mv gradeInvolution(mv x) {
	return ::g2bi::grade_involution(x);
}