// assume that F2CAD_USE_Fadbad is defined
# include <f2cad/f2cad.hpp>

namespace {
	static bool Recording  = false; // currently recording a function
	static int Domain      = 0;     // domain dimension
	static int Range       = 0;     // range dimension
	static doublereal *Fun = 0;     // currently defined function object
}

namespace f2cad {

void Independent(integer n, doublereal *x)
{
	// check not two Independents in a row
	assert( ! Recording );

	// make sure the set of independent variables not empty
	assert( n > 0 );

	// delete old function object
	if( Fun != 0 )
	{	delete [] Fun;
		Fun = 0;
	}

	// declare independent variables
	int j;
	for(j = 0; j < n; j++)
		x[j].diff(j, n);

	// change to recording state
	Recording = true;
	Domain    = n;
	Range     = 0;

	return;
}

void Dependent(integer m, doublereal *y)
{
	// check that directly follows call to Independent
	assert( Recording );
	assert( Range == 0 );
	assert( Fun == 0 );

	// make sure the set of dependent variables is not empty
	assert( m > 0 );

	// create the function object
	Fun = new doublereal[m];
	int i;
	for(i = 0; i < m; i++)
		Fun[i] = y[i];

	// stop the recording
	Range     = m;
	Recording = false;
}


// linked here from Partial<doublereal>(integer i, integer j)
double Partial(const doublereal &zero, integer i, integer j)
{
	// check that function is defined
	assert( ! Recording );
	assert( Fun != 0 );

	assert( 0 <= i );
	assert( 0 <= j );
	assert( i < Range );
	assert( j < Domain );
	assert( zero == doublereal(0) );

	// compute dy
	return Fun[i].d(j);
}

double Value(const doublereal &z)
{	// value member function is not const
	doublereal tmp = z;
	return tmp.x(); 
}

doublereal Sign(const doublereal* x, const doublereal* y)
{	if( *y >= 0. )
		return abs(*x);
	return -abs(*x);
}

} // end f2cad namespace