Calculators.ecs

#ecs; // enable support for @@symbols and :: operator
using System(, .Collections.Generic, .Linq, .Text);
using Loyc(, .Syntax, .Collections);

namespace LesGraphingCalc
{
    using number = System.Double; // Change this line to make a calculator for a different data type 

    class CalcRange
    {
        // Generate a constructor and three public fields
        public this(public number Lo, public number Hi, public int PxCount)
        {
            StepSize = (Hi - Lo) / Math.Max(PxCount - 1, 1);
        }
        public number StepSize;
        public number ValueToPx(number value) => (value - Lo) / (Hi - Lo) * PxCount;
        public number PxToValue(int px) => (number)px / PxCount * (Hi - Lo) + Lo;
        public number PxToDelta(int px) => (number)px / PxCount * (Hi - Lo);
        public CalcRange DraggedBy(int dPx) =>
            new CalcRange(Lo - PxToDelta(dPx), Hi - PxToDelta(dPx), PxCount);
        public CalcRange ZoomedBy(number ratio)
        {
            double mid = (Hi + Lo) / 2, halfSpan = (Hi - Lo) * ratio / 2;
            return new CalcRange(mid - halfSpan, mid + halfSpan, PxCount);
        }
    }

    // "alt class" generates an entire class hierarchy with base class CalculatorCore and 
    // read-only fields. Each "alternative" (derived class) is marked with the word "alt".
    abstract alt class CalculatorCore
    {
        // Base class constructor and fields
        alt this(LNode Expr, Dictionary<Symbol, LNode> Vars, CalcRange XRange);

        public object Results { get; protected set; }

        // Derived class for 2D graphing calculator
        alt Calculator2D()
        {
            public override object Run()
            {
                var results = new number[XRange.PxCount];
                number x = XRange.Lo;
                
                Func<Symbol, number> lookup = null;
                lookup = name => (name == @@x ? x : Eval(Vars[name], lookup));
                
                for (int i = 0; i < results.Length; i++) {
                    results[i] = Eval(Expr, lookup);
                    x += XRange.StepSize;
                }
                return Results = results;
            }
            public override number? GetValueAt(int x, int _) =>
                (uint)x < (uint)((number[])Results)::r.Length ? r[x] : (number?)null;
        }

        // Derived class for pseudo-3D and "equation" calculator
        alt Calculator3D(CalcRange YRange)
        {
            public bool EquationMode { get; private set; }
 
            public override object Run()
            {
                matchCode(Expr) {
                    // If we're given an equation like "x**2 = y**2", change it to
                    // "x**2 - y**2" and plot transitions in sign
                    case $L = $R, $L == $R:
                        EquationMode = true;
                        number[,] results = RunCore(quote($L - $R), true);
                        number[,] results2 = new number[results.GetLength(0) - 1, results.GetLength(1) - 1];
                        for (int i = 0; i < results.GetLength(0)-1; i++) {
                            for (int j = 0; j < results.GetLength(1)-1; j++) {
                                int sign = Math.Sign(results[i, j]);
                                if (sign == 0 || sign != Math.Sign(results[i+1, j]) ||
                                                 sign != Math.Sign(results[i, j+1]) ||
                                                 sign != Math.Sign(results[i+1, j+1]))
                                    results2[i, j] = (number)1;
                                else
                                    results2[i, j] = (number)0;
                            }
                        }
                        return Results = results2;
                    default:
                        EquationMode = Expr.ArgCount == 2 && Expr.Name.IsOneOf(
                            CodeSymbols.GT, CodeSymbols.LT, CodeSymbols.GE, CodeSymbols.LE, CodeSymbols.Neq, CodeSymbols.And, CodeSymbols.Or);
                        return Results = RunCore(Expr, false);
                }
            }
            public number[,] RunCore(LNode expr, bool difMode)
            {
                var results = new number[YRange.PxCount + (difMode?1:0),
                                         XRange.PxCount + (difMode?1:0)];
                number x = XRange.Lo, startx = x;
                number y = YRange.Lo;
                if (difMode) {
                    x -= XRange.StepSize / 2;
                    y -= YRange.StepSize / 2;
                }

                Func<Symbol, number> lookup = null;
                lookup = name => (name == @@x ? x : name == @@y ? y : Eval(Vars[name], lookup));

                for (int yi = 0; yi < results.GetLength(0); yi++, x = startx) {
                    for (int xi = 0; xi < results.GetLength(1); xi++) {
                        results[yi, xi] = Eval(expr, lookup);
                        x += XRange.StepSize;
                    }
                    y += YRange.StepSize;
                }
                return results;
            }
            public override number? GetValueAt(int x, int y) =>
                (uint)x < (uint)((number[,])Results)::r.GetLength(1) &&
                (uint)y < (uint)r.GetLength(0) ? r[y, x] : (number?)null;
        }

        public abstract object Run();
        public abstract number? GetValueAt(int x, int y);

        public static CalculatorCore New(LNode expr, Dictionary<Symbol, LNode> vars, CalcRange xRange, CalcRange yRange)
        {
            // Find out if the expression uses the variable "y" (or is an equation with '=' or '==')
            // As an (unnecessary) side effect, this throws if an unreferenced var is used
            bool isEquation = expr.Calls(CodeSymbols.Assign, 2) || expr.Calls(CodeSymbols.Eq, 2), usesY = false;
            if (!isEquation) {
                LNode zero = LNode.Literal((double) 0);
                Func<Symbol, double> lookup = null;
                lookup = name => name == @@x || (usesY |= name == @@y) ? 0 : Eval(vars[name], lookup);
                Eval(expr, lookup);
            }
            if (isEquation || usesY)
                return new Calculator3D(expr, vars, xRange, yRange);
            else
                return new Calculator2D(expr, vars, xRange);
        }

        // Parse the list of variables provided in the GUI
        public static Dictionary<Symbol, LNode> ParseVarList(IEnumerable<LNode> varList)
        {
            var vars = new Dictionary<Symbol, LNode>();
            foreach (LNode assignment in varList) {
                matchCode (assignment) {
                    case $var = $expr:
                        if (!var.IsId)
                            throw new ArgumentException("Left-hand side of '=' must be a variable name: {0}".Localized(var));
                        
                        // For efficiency, try to evaluate the expression in advance
                        try { expr = LNode.Literal(Eval(expr, vars)); } 
                        catch { } // it won't work if expression uses X or Y
                        
                        vars.Add(var.Name, expr);
                    default:
                        throw new ArgumentException("Expected assignment expression: {0}".Localized(assignment));
                };
            }
            return vars;
        }

        public static number Eval(LNode expr, Dictionary<Symbol, LNode> vars)
        {
            Func<Symbol, number> lookup = null;
            lookup = name => Eval(vars[name], lookup);
            return Eval(expr, lookup);
        }

        // Evaluates an expression
        public static number Eval(LNode expr, Func<Symbol, number> lookup)
        {
            if (expr.IsLiteral) {
                if (expr.Value is number)
                    return (number)expr.Value;
                else
                    return (number)Convert.ToDouble(expr.Value);
            }
            if (expr.IsId)
                return lookup(expr.Name);

            // expr must be a function or operator
            if (expr.ArgCount == 2) {
                // Binary operators are the most common...
                matchCode (expr) { 
                    case $a + $b:     return Eval(a, lookup) + Eval(b, lookup);
                    case $a * $b:     return Eval(a, lookup) * Eval(b, lookup);
                    case $a - $b:     return Eval(a, lookup) - Eval(b, lookup);
                    case $a / $b:     return Eval(a, lookup) / Eval(b, lookup);
                    case $a % $b:     return Eval(a, lookup) % Eval(b, lookup);
                    case $a ** $b:    return (number) Math.Pow(Eval(a, lookup), Eval(b, lookup));
                    case $a >> $b:    return (number) G.ShiftRight(Eval(a, lookup), (int)Eval(b, lookup));
                    case $a << $b:    return (number) G.ShiftLeft(Eval(a, lookup), (int)Eval(b, lookup));
                    case $a >  $b:    return Eval(a, lookup) > Eval(b, lookup)  ? (number)1 : (number)0;
                    case $a <  $b:    return Eval(a, lookup) < Eval(b, lookup)  ? (number)1 : (number)0;
                    case $a >= $b:    return Eval(a, lookup) >= Eval(b, lookup) ? (number)1 : (number)0;
                    case $a <= $b:    return Eval(a, lookup) <= Eval(b, lookup) ? (number)1 : (number)0;
                    case $a == $b:    return Eval(a, lookup) == Eval(b, lookup) ? (number)1 : (number)0;
                    case $a != $b:    return Eval(a, lookup) != Eval(b, lookup) ? (number)1 : (number)0;
                    case $a & $b:     return (number)((long)Eval(a, lookup) & (long)Eval(b, lookup));
                    case $a | $b:     return (number)((long)Eval(a, lookup) | (long)Eval(b, lookup));
                    case $a ?? $b:    return double.IsNaN(Eval(a, lookup)::a2) | double.IsInfinity(a2) ? Eval(b, lookup) : a2;
                    case $a && $b, @`'and`($a, $b): return Eval(a, lookup) != (number)0 ? Eval(b, lookup) : (number)0;
                    case $a || $b, @`'or`($a, $b):  return Eval(a, lookup) == (number)0 ? Eval(b, lookup) : (number)1;
                    case @`'xor`($a, $b):           return (Eval(a, lookup) != 0) != (Eval(b, lookup) != 0) ? (number)1 : (number)0;
                    case xor($a, $b): return (number)((long)Eval(a, lookup) ^ (long)Eval(b, lookup));
                    case min($a, $b): return Math.Min(Eval(a, lookup), Eval(b, lookup));
                    case max($a, $b): return Math.Max(Eval(a, lookup), Eval(b, lookup));
                    case mod($a, $b), @`'MOD`($a, $b): return Mod(Eval(a, lookup), Eval(b, lookup));
                    case atan($a, $b): return Math.Atan2(Eval(a, lookup), Eval(b, lookup));
                    case log($a, $b):  return Math.Log(Eval(a, lookup), Eval(b, lookup));
                    case @`'in`($a, ($lo, $hi)): return G.IsInRange(Eval(a, lookup), Eval(lo, lookup), Eval(hi, lookup)) ? (number)1 : (number)0;
                    case @`'clamp`($a, ($lo, $hi)), clamp($a, $lo, $hi): return G.PutInRange(Eval(a, lookup), Eval(lo, lookup), Eval(hi, lookup));
                    case @`'P`($a, $b), P($a, $b): return P((int)Math.Round(Eval(a, lookup)), (int)Math.Round(Eval(b, lookup)));
                    case @`'C`($a, $b), C($a, $b): return C((ulong)Math.Round(Eval(a, lookup)), (ulong)Math.Round(Eval(b, lookup)));
                }
            }
            // Other stuff
            matchCode (expr) {
                case -$a: return -Eval(a, lookup);
                case +$a: return Math.Abs(Eval(a, lookup));
                case !$a: return  Eval(a, lookup) == 0 ? (number)1 : (number)0;
                case ~$a: return (number)~(long)Eval(a, lookup);
                // In LES, the conditional operator a?b:c is actually two separate binary 
                // operators named '? and ': ... so if we use C# syntax $c ? $a : $b here,
                // it will NOT work. Note: @`'?` represents the identifier called '? in EC#
                case @`'?`($c, @`':`($a, $b)):
                    return Eval(c, lookup) != (number)0 ? Eval(a, lookup) : Eval(b, lookup);
                case square($a):  return Eval(a, lookup)::n * n;
                case sqrt($a):    return Math.Sqrt(Eval(a, lookup));
                case sin($a):     return Math.Sin(Eval(a, lookup));
                case cos($a):     return Math.Cos(Eval(a, lookup));
                case tan($a):     return Math.Tan(Eval(a, lookup));
                case asin($a):    return Math.Asin(Eval(a, lookup));
                case acos($a):    return Math.Acos(Eval(a, lookup));
                case atan($a):    return Math.Atan(Eval(a, lookup));
                case sec($a):     return 1/Math.Cos(Eval(a, lookup));
                case csc($a):     return 1/Math.Sin(Eval(a, lookup));
                case cot($a):     return 1/Math.Tan(Eval(a, lookup));
                case exp($a):     return Math.Exp(Eval(a, lookup));
                case ln($a):      return Math.Log(Eval(a, lookup));
                case log($a):     return Math.Log10(Eval(a, lookup));
                case ceil($a):    return Math.Ceiling(Eval(a, lookup));
                case floor($a):   return Math.Floor(Eval(a, lookup));
                case sign($a):    return Math.Sign(Eval(a, lookup));
                case abs($a):     return Math.Abs(Eval(a, lookup));
                case rnd():       return (number)_r.NextDouble();
                case rnd($a):     return (number)_r.Next((int)Eval(a, lookup));
                case rnd($a, $b): return (number)_r.Next((int)Eval(a, lookup), (int)Eval(b, lookup));
                case fact($a):    return Factorial(Eval(a, lookup));
            }
            throw new ArgumentException("Expression not understood: {0}".Localized(expr));
        }

        static double Mod(double x, double y)
        {
            double m = x % y;
            return m + (m < 0 ? y : 0);
        }
        static double Factorial(double n) => 
			n <= 1 ? 1 : n * Factorial(n - 1);
        static double P(int n, int k) =>
            k <= 0 ? 1 : k > n ? 0 : n * P(n - 1, k - 1);
        static double C(ulong n, ulong k) {
            if (k > n) return 0;
            k = Math.Min(k, n - k);
            double result = 1;
            for (ulong d = 1; d <= k; ++d) {
                result *= n--;
                result /= d;
            }
            return result;
        }
        static Random _r = new Random();
    }
}