import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
@Override
public double classifyInstance(Instance instance) throws Exception {
	//System.out.println(instance);
	Evaluator evaluator = new Evaluator();
	Double res=0.0;
	int index = model.getInputSpace().size();
   	for( String outVar : model.getOutputSpace().keySet()){
   		String tempFunction = new String(functions.get(outVar));;
   		int inputIndex=0;
   		for(String inVar: model.getInputSpace().keySet()){
   			//System.out.println(inVar+" "+instance.value(inputIndex));
   			tempFunction=tempFunction.replace(inVar, instance.value(inputIndex)+"");
   			inputIndex++;
   		}
   		res = Double.parseDouble(evaluator.evaluate(tempFunction));
   		//System.out.println("adding: "+outVar + " " +tempFunction+" "+res);
   		instance.setValue(new Attribute(outVar,index++), res);
   	}
	//System.out.println(instance);
	//System.out.println(res);
	return res;
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The ceiling of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.ceil(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The cosine of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.cos(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The arc sine of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.asin(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A long value that is closest to the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Long result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Long(Math.round(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The absolute value of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.abs(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A measurement of the argument in degrees.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(Evaluator evaluator, String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.toDegrees(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The arc cosine value of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.acos(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted into two double
 *            values and evaluated.
 * 
 * @return The smaller of two values.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;

	ArrayList numbers = FunctionHelper.getDoubles(arguments, 
			EvaluationConstants.FUNCTION_ARGUMENT_SEPARATOR);

	if (numbers.size() != 2) {
		throw new FunctionException("Two numeric arguments are required.");
	}

	try {
		double argumentOne = ((Double) numbers.get(0)).doubleValue();
		double argumentTwo = ((Double) numbers.get(1)).doubleValue();
		result = new Double(Math.min(argumentOne, argumentTwo));
	} catch (Exception e) {
		throw new FunctionException("Two numeric arguments are required.", e);
	}

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted into two double
 *            values and evaluated.
 * 
 * @return The arc tangent2 value of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;

	ArrayList numbers = FunctionHelper.getDoubles(arguments, 
			EvaluationConstants.FUNCTION_ARGUMENT_SEPARATOR);

	if (numbers.size() != 2) {
		throw new FunctionException("Two numeric arguments are required.");
	}

	try {
		double argumentOne = ((Double) numbers.get(0)).doubleValue();
		double argumentTwo = ((Double) numbers.get(1)).doubleValue();
		result = new Double(Math.atan2(argumentOne, argumentTwo));
	} catch (Exception e) {
		throw new FunctionException("Two numeric arguments are required.", e);
	}

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The floor of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.floor(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The the value e to the argument power, where e is the base of the
 *         natural logarithms
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.exp(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A trigonometric tangent of an angle.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(Evaluator evaluator, String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.tan(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted into two double
 *            values and evaluated.
 * 
 * @return The value of the first argument raised to the second power of the
 *         second argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;

	ArrayList numbers = FunctionHelper.getDoubles(arguments, 
			EvaluationConstants.FUNCTION_ARGUMENT_SEPARATOR);

	if (numbers.size() != 2) {
		throw new FunctionException("Two numeric arguments are required.");
	}

	try {
		double argumentOne = ((Double) numbers.get(0)).doubleValue();
		double argumentTwo = ((Double) numbers.get(1)).doubleValue();
		result = new Double(Math.pow(argumentOne, argumentTwo));
	} catch (Exception e) {
		throw new FunctionException("Two numeric arguments are required.", e);
	}

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted into two double
 *            values and evaluated.
 * 
 * @return The the remainder operation on two arguments as prescribed by the
 *         IEEE 754 standard.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;

	ArrayList numbers = FunctionHelper.getDoubles(arguments, 
			EvaluationConstants.FUNCTION_ARGUMENT_SEPARATOR);

	if (numbers.size() != 2) {
		throw new FunctionException("Two numeric arguments are required.");
	}

	try {
		double argumentOne = ((Double) numbers.get(0)).doubleValue();
		double argumentTwo = ((Double) numbers.get(1)).doubleValue();
		result = new Double(Math.IEEEremainder(argumentOne, argumentTwo));
	} catch (Exception e) {
		throw new FunctionException("Two numeric arguments are required.", e);
	}

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return The arc tangent of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.atan(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A measurement of the argument in radians.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(Evaluator evaluator, String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.toRadians(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A double value that is closest in value to the argument and is
 *         equal to a mathematical integer.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.rint(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted to a double value and
 *            evaluated.
 * 
 * @return A square root of the argument.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;
	Double number = null;

	try {
		number = new Double(arguments);
	} catch (Exception e) {
		throw new FunctionException("Invalid argument.", e);
	}

	result = new Double(Math.sqrt(number.doubleValue()));

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}
 

import net.sourceforge.jeval.Evaluator; //导入依赖的package包/类
/**
 * Executes the function for the specified argument. This method is called
 * internally by Evaluator.
 * 
 * @param evaluator
 *            An instance of Evaluator.
 * @param arguments
 *            A string argument that will be converted into two double
 *            values and evaluated.
 * 
 * @return The greater of two values.
 * 
 * @exception FunctionException
 *                Thrown if the argument(s) are not valid for this function.
 */
public FunctionResult execute(final Evaluator evaluator, final String arguments)
		throws FunctionException {
	Double result = null;

	ArrayList numbers = FunctionHelper.getDoubles(arguments, 
			EvaluationConstants.FUNCTION_ARGUMENT_SEPARATOR);

	if (numbers.size() != 2) {
		throw new FunctionException("Two numeric arguments are required.");
	}

	try {
		double argumentOne = ((Double) numbers.get(0)).doubleValue();
		double argumentTwo = ((Double) numbers.get(1)).doubleValue();
		result = new Double(Math.max(argumentOne, argumentTwo));
	} catch (Exception e) {
		throw new FunctionException("Two numeric arguments are required.", e);
	}

	return new FunctionResult(result.toString(), 
			FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC);
}