OoasTools

/**

  *

  *                      OOAS Compiler (Deprecated)

  *

  * Copyright 2015, Institute for Software Technology, Graz University of

  * Technology. Portions are copyright 2015 by the AIT Austrian Institute

  * of Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * Please notice that this version of the OOAS compiler is considered de-

  * precated. Only the Java version is maintained.

  *

  * Contributors:

  *               Willibald Krenn (TU Graz/AIT)

  *               Stefan Tiran (TU Graz/AIT)

  */

using System;

using System.Collections.Generic;

using System.Text;

namespace TUG.Mogentes

{

    public abstract class AbstractOperations

    {

        public abstract AbstractRange GenericArithmeticCover(AbstractRange type1, AbstractRange type2, ExpressionKind op);

    }

    public class Operations<T> : AbstractOperations

    {

        public delegate T opUnary(T input);

        public delegate T opBinary(T inputA, T inputB);

        public delegate bool opBinRel(T inputA, T intputB);

        public opUnary unaryNotImplemented = p => { throw new NotImplementedException(); };

        public opBinary binaryNotImplemented = (a, b) => { throw new NotImplementedException(); };

        public opBinRel binrelNotImplemented = (a, b) => { throw new NotImplementedException(); };

        // not all operations may be defined, then there needs to be some excpetion..

        public opUnary unMinus;

        public opBinary minus;

        public opBinary plus;

        public opBinary div;

        public opBinary pow;

        public opBinary prod;

        public opBinary mod;

        public opBinRel equal;

        public opBinRel smaller;

        public opBinRel greater;

        public override AbstractRange GenericArithmeticCover(AbstractRange type1, AbstractRange type2, ExpressionKind op)

        {

            Range<T> a = type1 as Range<T>;

            Range<T> b = type2 as Range<T>;

            if (a == null || b == null)

                throw new ArgumentException();

            return GenericArithmeticCover(a, b, op);

        }

        public Range<T> GenericArithmeticCover(Range<T> type1, Range<T> type2, ExpressionKind op)

        {

            Range<T> result = type1.Create(default(T), default(T));

            Operations<T> o = this; // remove this if method remains in this class..

            switch (op)

            {

                case ExpressionKind.unminus:

                    result.min = o.unMinus(type1.max);

                    result.max = o.unMinus(type1.min);

                    break;

                case ExpressionKind.unplus:

                    break;

                case ExpressionKind.minus:

                    System.Diagnostics.Debug.Assert(type2 != null);

                    // we do some sort of resulttype = type1 - type2

                    // hence, do the unminus stuff with type 2

                    T spare = type2.max;

                    type2.max = o.unMinus(type2.min);

                    type2.min = o.unMinus(spare);

                    // now it's the same with sum.. but c# does not let us fall through..

                    result.min = o.plus(type1.min, type2.min);

                    result.max = o.plus(type1.max, type2.max);

                    break;

                case ExpressionKind.sum:

                    System.Diagnostics.Debug.Assert(type2 != null);

                    result.min = o.plus(type1.min, type2.min);

                    result.max = o.plus(type1.max, type2.max);

                    break;

                case ExpressionKind.idiv:

                case ExpressionKind.div:

                    System.Diagnostics.Debug.Assert(type2 != null);

                    type2.min = o.equal(type2.min, default(T)) ? o.unMinus(type2.precision) : type2.min;

                    type2.max = o.equal(type2.max, default(T)) ? type2.precision : type2.max;

                    // hmm, brute force.. is there some formula?

                    result.max = o.div(type1.min, type2.min);

                    result.min = result.max;

                    T tmp = o.div(type1.max, type2.min);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    tmp = o.div(type1.min, type2.max);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    tmp = o.div(type1.max, type2.max);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    break;

                case ExpressionKind.mod:

                    throw new ArgumentException(); // do this one level up

                case ExpressionKind.pow:

                    // ok, this is bad. - just give up here

                    result.max = result.typemax;

                    result.min = result.typemin;

                    break;

                case ExpressionKind.prod:

                    // hmm, brute force.. is there some formula?

                    result.max = o.prod(type1.min, type2.min);

                    result.min = result.max;

                    tmp = o.prod(type1.max, type2.min);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    tmp = o.prod(type1.min, type2.max);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    tmp = o.prod(type1.max, type2.max);

                    result.max = o.smaller(result.max, tmp) ? tmp : result.max;

                    result.min = o.greater(result.min, tmp) ? tmp : result.min;

                    break;

                default:

                    throw new NotImplementedException();

            }

            return result;

        }

        public Operations()

        {

            unMinus = unaryNotImplemented;

            minus = binaryNotImplemented;

            plus = binaryNotImplemented;

            div = binaryNotImplemented;

            pow = binaryNotImplemented;

            prod = binaryNotImplemented;

            mod = binaryNotImplemented;

            equal = binrelNotImplemented;

            smaller = binrelNotImplemented;

            greater = binrelNotImplemented;

        }

        public Operations(opUnary aUnMinus,

            opBinary aMinus,

            opBinary aPlus,

            opBinary aDiv,

            opBinary aPow,

            opBinary aProd,

            opBinary aMod,

            opBinRel aEquality,

            opBinRel aSmaller,

            opBinRel aGreater)

        {

            unMinus = aUnMinus;

            minus = aMinus;

            plus = aPlus;

            div = aDiv;

            pow = aPow;

            prod = aProd;

            mod = aMod;

            equal = aEquality;

            smaller = aSmaller;

            greater = aGreater;

        }

    }

    public sealed class IntegerOperations : Operations<int>

    {

        public IntegerOperations()

            : base(p => -p,

            (a, b) => a - b,

            (a, b) => a + b,

            (a, b) => a / b,

            (a, b) => (int)Math.Pow(a, b),

            (a, b) => a * b,

            (a, b) => a % b,

            (a, b) => a == b,

            (a, b) => a < b,

            (a, b) => a > b)

        { }

    }

    public sealed class CheckedIntegerOperations : Operations<int>

    {

        public CheckedIntegerOperations()

            : base(p => { checked { return -p; } },

            (a, b) => { checked { return a - b; } },

            (a, b) => { checked { return a + b; } },

            (a, b) => { checked { return a / b; } },

            (a, b) => { checked { return (int)Math.Pow(a, b); } },

            (a, b) => { checked { return a * b; } },

            (a, b) => a % b,

            (a, b) => a == b,

            (a, b) => a < b,

            (a, b) => a > b)

        { }

    }

    public sealed class SaturatedIntegerOperations : Operations<int>

    {

        private static int SatUnMinus(int input)

        {

            return input == int.MinValue ? int.MaxValue : -input;

        }

        private static int Subtraction(int a, int b)

        {

            if (b < 0)

                return (a > int.MaxValue + b) ? int.MaxValue : a - b;

            else

                return (a < int.MinValue + b) ? int.MinValue : a - b;

        }

        private static int Addition(int a, int b)

        {

            if (b < 0)

                return (a < int.MinValue - b) ? int.MinValue : a + b;

            else

                return (a > int.MaxValue - b) ? int.MaxValue : a + b;

        }

        private static int Division(int a, int b)

        {

            checked { return a / b; };

        }

        private static int Power(int a, int b)

        {

            Int64 tmp = (Int64)Math.Pow(a, b);

            if (tmp < int.MinValue) return int.MinValue;

            else if (tmp > int.MaxValue) return int.MaxValue;

            else return (int)tmp;

        }

        private static int Multiplication(int a, int b)

        {

            Int64 tmp = Math.BigMul(a, b);

            if (tmp < int.MinValue) return int.MinValue;

            else if (tmp > int.MaxValue) return int.MaxValue;

            else return (int)tmp;

        }

        public SaturatedIntegerOperations()

            : base(SatUnMinus, Subtraction, Addition, Division, Power, Multiplication,

            (a, b) => a % b,

            (a, b) => a == b,

            (a, b) => a < b,

            (a, b) => a > b)

        { }

    }

    public sealed class DoubleOperations : Operations<double>

    {

        public DoubleOperations()

            : base(p => -p,

            (a, b) => a - b,

            (a, b) => a + b,

            (a, b) => a / b,

            (a, b) => Math.Pow(a, b),

            (a, b) => a * b,

            (a, b) => a % b,

            (a, b) => a == b,

            (a, b) => a < b,

            (a, b) => a > b)

        { }

    }

    public sealed class SaturatedDoubleOperations : Operations<double>

    {

        private static double checkRange(double aValue)

        {

            if (aValue == double.PositiveInfinity)

                return double.MaxValue;

            else if (aValue == double.NegativeInfinity)

                return double.MinValue;

            else

                return aValue;

        }

        private static double SatUnMinus(double input)

        {

            return checkRange(-input);

        }

        private static double Subtraction(double a, double b)

        {

            return checkRange(a - b);

        }

        private static double Addition(double a, double b)

        {

            return checkRange(a + b);

        }

        private static double Division(double a, double b)

        {

            return checkRange(a / b);

        }

        private static double Power(double a, double b)

        {

            return checkRange(Math.Pow(a, b));

        }

        private static double Multiplication(double a, double b)

        {

            return checkRange(a * b);

        }

        private static double Reminder(double a, double b)

        {

            return checkRange(a % b);

        }

        public SaturatedDoubleOperations()

            : base(SatUnMinus,

            Subtraction,

            Addition,

            Division,

            Power,

            Multiplication,

            Reminder,

            (a, b) => a == b,

            (a, b) => a < b,

            (a, b) => a > b)

        { }

    }

}