package com.googlecode.prolog_cafe.lang;

import com.googlecode.prolog_cafe.exceptions.IllegalDomainException;
import com.googlecode.prolog_cafe.exceptions.PInstantiationException;

/**
 * The <code>Arithmetic</code> class contains a method
 * for evaluating arithmetic expressions.<br>
 * This class is mainly used by the builtin predicate <code>is/2</code>.
 *
 * @author Mutsunori Banbara (banbara@kobe-u.ac.jp)
 * @author Naoyuki Tamura (tamura@kobe-u.ac.jp)
 * @version 1.0
 */
public class Arithmetic {
    static final SymbolTerm SYM_RANDOM       = SymbolTerm.intern("random");
    static final SymbolTerm SYM_PI           = SymbolTerm.intern("pi");
    static final SymbolTerm SYM_E            = SymbolTerm.intern("e");
    static final SymbolTerm SYM_ADD_1        = SymbolTerm.intern("+", 1);
    static final SymbolTerm SYM_NEGATE_1     = SymbolTerm.intern("-", 1);
    static final SymbolTerm SYM_ADD_2        = SymbolTerm.intern("+", 2);
    static final SymbolTerm SYM_SUBTRACT_2   = SymbolTerm.intern("-", 2);
    static final SymbolTerm SYM_MULTIPLY_2   = SymbolTerm.intern("*", 2);
    static final SymbolTerm SYM_DIVIDE_2     = SymbolTerm.intern("/", 2);
    static final SymbolTerm SYM_INTDIVIDE_2  = SymbolTerm.intern("//", 2);
    static final SymbolTerm SYM_MOD_2        = SymbolTerm.intern("mod", 2);
    static final SymbolTerm SYM_SHIFTLEFT_2  = SymbolTerm.intern("<<", 2);
    static final SymbolTerm SYM_SHIFTRIGHT_2 = SymbolTerm.intern(">>", 2);
    static final SymbolTerm SYM_NOT_1        = SymbolTerm.intern("\\", 1);
    static final SymbolTerm SYM_AND_2        = SymbolTerm.intern("/\\", 2);
    static final SymbolTerm SYM_OR_2         = SymbolTerm.intern("\\/", 2);
    static final SymbolTerm SYM_XOR_2        = SymbolTerm.intern("#", 2);
    static final SymbolTerm SYM_POW_2        = SymbolTerm.intern("**", 2);
    static final SymbolTerm SYM_ABS_1        = SymbolTerm.intern("abs", 1);
    static final SymbolTerm SYM_ACOS_1       = SymbolTerm.intern("acos", 1);
    static final SymbolTerm SYM_ASIN_1       = SymbolTerm.intern("asin", 1);
    static final SymbolTerm SYM_ATAN_1       = SymbolTerm.intern("atan", 1);
    static final SymbolTerm SYM_CEIL_1       = SymbolTerm.intern("ceiling", 1);
    static final SymbolTerm SYM_COS_1        = SymbolTerm.intern("cos", 1);
    static final SymbolTerm SYM_DEGREES_1    = SymbolTerm.intern("degrees", 1);
    static final SymbolTerm SYM_EXP_1        = SymbolTerm.intern("exp", 1);
    static final SymbolTerm SYM_FLOOR_1      = SymbolTerm.intern("floor", 1);
    static final SymbolTerm SYM_LOG_1        = SymbolTerm.intern("log", 1);
    static final SymbolTerm SYM_MAX_2        = SymbolTerm.intern("max", 2);
    static final SymbolTerm SYM_MIN_2        = SymbolTerm.intern("min", 2);
    static final SymbolTerm SYM_RADIANS_1    = SymbolTerm.intern("radians", 1);
    static final SymbolTerm SYM_RINT_1       = SymbolTerm.intern("rint", 1);
    static final SymbolTerm SYM_ROUND_1      = SymbolTerm.intern("round", 1);
    static final SymbolTerm SYM_SIN_1        = SymbolTerm.intern("sin", 1);
    static final SymbolTerm SYM_SQRT_1       = SymbolTerm.intern("sqrt", 1);
    static final SymbolTerm SYM_TAN_1        = SymbolTerm.intern("tan", 1);
    static final SymbolTerm SYM_REM_2        = SymbolTerm.intern("rem", 2);
    static final SymbolTerm SYM_SIGN_1       = SymbolTerm.intern("sign", 1);
    static final SymbolTerm SYM_FLOAT_1      = SymbolTerm.intern("float", 1);
    static final SymbolTerm SYM_INTPART_1    = SymbolTerm.intern("float_integer_part", 1);
    static final SymbolTerm SYM_FRACTPART_1  = SymbolTerm.intern("float_fractional_part", 1);
    static final SymbolTerm SYM_TRUNCATE_1   = SymbolTerm.intern("truncate", 1);

    /**
     * Evaluates <code>_t</code> as an arithmetic expression, 
     * and returns the resulting number as <code>NumberTerm</code>.
     *
     * @exception PInstantiationException if <code>_t</code> contains unbound variables.
     * @exception IllegalDomainException if <code>_t</code> is not an arithmetic expression.
     */
    public static NumberTerm evaluate(Term _t) 
	throws PInstantiationException,IllegalDomainException {
	Term t = _t.dereference();

	if (t instanceof VariableTerm)
	    throw new PInstantiationException();
	else if (t instanceof IntegerTerm)
	    return (IntegerTerm)t;
	else if (t instanceof DoubleTerm)
	    return (DoubleTerm)t;
	else if (t.equals(SYM_RANDOM))
	    return new DoubleTerm(Math.random());
	else if (t.equals(SYM_PI))
	    return new DoubleTerm(Math.PI);
	else if (t.equals(SYM_E))
	    return new DoubleTerm(Math.E);
	else if (t instanceof ListTerm)
	    return evaluate(((ListTerm)t).car());
	else if (! (t instanceof StructureTerm)) 
	    throw new IllegalDomainException("arithmetic expression", t);

	SymbolTerm func = ((StructureTerm)t).functor();
	Term[] args = ((StructureTerm)t).args();

	if (func.equals(SYM_ADD_1))
	    return evaluate(args[0]);
	else if (func.equals(SYM_NEGATE_1))
	    return evaluate(args[0]).negate();
	else if (func.equals(SYM_ADD_2))
	    return evaluate(args[0]).add(evaluate(args[1]));
	else if (func.equals(SYM_SUBTRACT_2))
	    return evaluate(args[0]).subtract(evaluate(args[1]));
	else if (func.equals(SYM_MULTIPLY_2))
	    return evaluate(args[0]).multiply(evaluate(args[1]));
	else if (func.equals(SYM_INTDIVIDE_2))
	    return evaluate(args[0]).intDivide(evaluate(args[1]));
	else if (func.equals(SYM_DIVIDE_2))
	    return evaluate(args[0]).divide(evaluate(args[1]));
	else if (func.equals(SYM_MOD_2))
	    return evaluate(args[0]).mod(evaluate(args[1]));
	else if (func.equals(SYM_REM_2))
	    return evaluate(args[0]).mod(evaluate(args[1]));
	else if (func.equals(SYM_AND_2))
	    return evaluate(args[0]).and(evaluate(args[1]));
	else if (func.equals(SYM_OR_2))
	    return evaluate(args[0]).or(evaluate(args[1]));
	else if (func.equals(SYM_XOR_2))
	    return evaluate(args[0]).xor(evaluate(args[1]));
	else if (func.equals(SYM_NOT_1))
	    return evaluate(args[0]).not();
	else if (func.equals(SYM_SHIFTLEFT_2))
	    return evaluate(args[0]).shiftLeft(evaluate(args[1]));
	else if (func.equals(SYM_SHIFTRIGHT_2))
	    return evaluate(args[0]).shiftRight(evaluate(args[1]));
	else if (func.equals(SYM_ABS_1))
	    return evaluate(args[0]).abs();
	else if (func.equals(SYM_MIN_2))
	    return evaluate(args[0]).min(evaluate(args[1]));
	else if (func.equals(SYM_MAX_2))
	    return evaluate(args[0]).max(evaluate(args[1]));
	else if (func.equals(SYM_RINT_1))
	    return evaluate(args[0]).rint();
	else if (func.equals(SYM_ROUND_1))
	    return evaluate(args[0]).round();
	else if (func.equals(SYM_FLOOR_1))
	    return evaluate(args[0]).floor();
	else if (func.equals(SYM_CEIL_1))
	    return evaluate(args[0]).ceil();
	else if (func.equals(SYM_SIN_1))
	    return evaluate(args[0]).sin();
	else if (func.equals(SYM_COS_1))
	    return evaluate(args[0]).cos();
	else if (func.equals(SYM_TAN_1))
	    return evaluate(args[0]).tan();
	else if (func.equals(SYM_ASIN_1))
	    return evaluate(args[0]).asin();
	else if (func.equals(SYM_ACOS_1))
	    return evaluate(args[0]).acos();
	else if (func.equals(SYM_ATAN_1))
	    return evaluate(args[0]).atan();
	else if (func.equals(SYM_SQRT_1))
	    return evaluate(args[0]).sqrt();
	else if (func.equals(SYM_LOG_1))
	    return evaluate(args[0]).log();
	else if (func.equals(SYM_EXP_1))
	    return evaluate(args[0]).exp();
	else if (func.equals(SYM_POW_2))
	    return evaluate(args[0]).pow(evaluate(args[1]));
	else if (func.equals(SYM_DEGREES_1))
	    return evaluate(args[0]).toDegrees();
	else if (func.equals(SYM_RADIANS_1))
	    return evaluate(args[0]).toRadians();
	else if (func.equals(SYM_SIGN_1))
	    return evaluate(args[0]).signum();
	else if (func.equals(SYM_FLOAT_1))
	    return evaluate(args[0]).toFloat();
	else if (func.equals(SYM_INTPART_1))
	    return evaluate(args[0]).floatIntPart();
	else if (func.equals(SYM_FRACTPART_1))
	    return evaluate(args[0]).floatFractPart();
	else if (func.equals(SYM_TRUNCATE_1))
	    return evaluate(args[0]).truncate();
	else
	    throw new IllegalDomainException("arithmetic expression", t);
    }
}