//  /*-------------------------------------------------------------------*\
//  |   Concrete Instance Body : Math_Operations
//  \*-------------------------------------------------------------------*/


///------------------------------------------------------------------------
/// Global Context --------------------------------------------------------
///------------------------------------------------------------------------

#include <math.h>
#include "RAW_Foundation.h"


///------------------------------------------------------------------------
/// Local Context ---------------------------------------------------------
///------------------------------------------------------------------------

#define MINIMUM_CHARACTER '\0'
#define MAXIMUM_CHARACTER '\377'
#define MINIMUM_INTEGER ((-2147483647)-1)
#define MAXIMUM_INTEGER 2147483647
#define MINIMUM_REAL -1.797693134e+308
#define MAXIMUM_REAL 1.797693134e+308


///------------------------------------------------------------------------
/// Public Operations -----------------------------------------------------
///------------------------------------------------------------------------

const Real m_pi = 3.14159265358979323846;
const Real m_e  = 2.7182818284590452354;

//-------------------------------------------------------------------------

Character Minimum_Character ()
{
    return Character (MINIMUM_CHARACTER);
}

//-------------------------------------------------------------------------

Character Maximum_Character ()
{
    return Character (MAXIMUM_CHARACTER);
}

//-------------------------------------------------------------------------

Integer Minimum_Integer ()
{
    return Integer (MINIMUM_INTEGER);
}

//-------------------------------------------------------------------------

Integer Maximum_Integer ()
{
    return Integer (MAXIMUM_INTEGER);
}

//-------------------------------------------------------------------------

Real Minimum_Real ()
{
    return Real (MINIMUM_REAL);
}

//-------------------------------------------------------------------------

Real Maximum_Real ()
{
    return Real (MAXIMUM_REAL);
}

//-------------------------------------------------------------------------

Real Sin (
	Real x
    )
{
    return sin (To_double (x));
}

//-------------------------------------------------------------------------

Real Cos (
	Real x
    )
{
    return cos (To_double (x));
}

//-------------------------------------------------------------------------

Real Tan (
	Real x
    )
{
    return tan (To_double (x));
}

//-------------------------------------------------------------------------

Real Arc_Sin (
	Real x
    )
{
    checking_assert ((-1.0 <= x) and (x <= 1.0), "-1.0 <= x <= 1.0");
    
    return asin (To_double (x));
}

//-------------------------------------------------------------------------

Real Arc_Cos (
	Real x
    )
{
    checking_assert ((-1.0 <= x) and (x <= 1.0), "-1.0 <= x <= 1.0");
    
    return acos (To_double (x));
}

//-------------------------------------------------------------------------

Real Arc_Tan (
	Real x
    )
{
    return atan (To_double (x));
}

//-------------------------------------------------------------------------

Real Sinh (
	Real x
    )
{
    return sinh (To_double (x));
}

//-------------------------------------------------------------------------

Real Cosh (
	Real x
    )
{
    return cosh (To_double (x));
}

//-------------------------------------------------------------------------

Real Tanh (
	Real x
    )
{
    return tanh (To_double (x));
}

//-------------------------------------------------------------------------

Integer Abs (
	Integer x
    )
{
    checking_assert (x != Minimum_Integer (),
		     "x /= MINIMUM_INTEGER");
    
    if (x < 0)
    {
        return 0 - x; // unary minus is not available
    }
    else
    {
        return x;
    }
}

//-------------------------------------------------------------------------

Integer Sign (
	Real x
    )
{
    if (x > 0.0)
    {
        return 1;
    }
    else if (x < 0.0)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

//-------------------------------------------------------------------------

Real Exp (
	Real x
    )
{
    return exp (To_double (x));
}

//-------------------------------------------------------------------------

Real Power (
	Real x,
	Real y
    )
{
    checking_assert (
            (
                (x > 0.0) or 
                (
                    (x == 0.0) and 
                    (y >= 0.0)
                ) or
                (
                    (x < 0.0) and 
                    (
                        (y == floor (To_double(y))) or 
                        (y == ceil  (To_double(y)))
                    )
                )
            ),
            "if x = 0.0 then y >= 0.0  and\n"
	    "if x < 0.0 then [y must be an integer]"
        );
    
    return pow (To_double (x), To_double (y));
}

//-------------------------------------------------------------------------

Real Ln (
	Real x)
{
    
    checking_assert (x > 0.0, "x > 0.0");
    
    return log (To_double (x));
}

//-------------------------------------------------------------------------

Real Log (
	Real x
    )
{
    checking_assert (x > 0.0, "x > 0.0");
    
    return log10 (To_double (x));
}

//-------------------------------------------------------------------------

Real Sqr (
	Real x
    )
{
    return x * x;
}

//-------------------------------------------------------------------------

Real Sqrt (
	Real x
    )
{
    checking_assert (x >= 0.0, "x >= 0.0");
    return sqrt (To_double (x));
}

//-------------------------------------------------------------------------

Real Ceiling (
	Real x
    )
{
    return ceil (To_double (x));
}

//-------------------------------------------------------------------------

Real Floor (
	Real x
    )
{
    return floor (To_double (x));
}

//-------------------------------------------------------------------------

Real Abs (
	Real x
    )
{
    return fabs (To_double (x));
}

//-------------------------------------------------------------------------

Boolean Is_Alpha (
        Character c
    )
{
    return (Boolean) isalpha (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Lower (
        Character c
    )
{
    return (Boolean) islower (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Upper (
        Character c
    )
{
    return (Boolean) isupper (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Digit (
        Character c
    )
{
    return (Boolean) isdigit (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_XDigit (
        Character c
    )
{
    return (Boolean) isxdigit (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Space (
        Character c
    )
{
    return (Boolean) isspace (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Control (
        Character c
    )
{
    return (Boolean) iscntrl (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Punctuation (
        Character c
    )
{
    return (Boolean) ispunct (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Alphanumeric (
        Character c
    )
{
    return (Boolean) isalnum (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Printable (
        Character c
    )
{
    return (Boolean) isprint (To_char (c));
}

//-------------------------------------------------------------------------

Boolean Is_Graphic (
        Character c
    )
{
    return (Boolean) isgraph (To_char (c));
}

//-------------------------------------------------------------------------

Character To_Lower (
        Character c
    )
{
    return (Character) tolower (To_char (c));
}

//-------------------------------------------------------------------------

Character To_Upper (
        Character c
    )
{
    return (Character) toupper (To_char (c));
}

//-------------------------------------------------------------------------