Replaced number implementation with one based on 64 bit ints

Yolol.Analysis/ControlFlowGraph/Builder.cs

@@ -143,7 +143,7 @@ private void HandleGoto(IMutableControlFlowGraph cfg, Goto @goto, IMutableBasicB
                 if (dest.Type == Execution.Type.Number)
                 {
                     // We know exactly where this is going, jump to that line
-                    var line = Math.Clamp((int)dest.Number.Value, 1, _maxLines);
+                    var line = Math.Clamp((int)dest.Number, 1, _maxLines);
                     var destBlock = GetLineEntryBlock(cfg, line);
                     cfg.CreateEdge(block, destBlock, EdgeType.GotoConstNum);
                 }

Yolol.Analysis/DataFlowGraph/DataFlowGraph.cs

@@ -507,7 +507,7 @@ protected override IDataFlowGraphExpressionNode Visit(Negate neg)
             protected override IDataFlowGraphExpressionNode Visit(ConstantNumber con)
             {
 
-                var op = new InputConst(Guid.NewGuid(), con.Value.Value);
+                var op = new InputConst(Guid.NewGuid(), new Value(con.Value));
                 _dataFlowGraph._inputs.Add(op);
                 return op;
             }

Yolol.Analysis/SAT/IModelVariable.cs

@@ -45,7 +45,7 @@ internal void AssertEq(Value value)
             switch (value.Type)
             {
                 case Type.Number:
-                    _model.Solver.Assert(ctx.MkEq(_numValue, _model.Context.MkInt((value.Number.Value * Number.Scale).ToString(CultureInfo.InvariantCulture))));
+                    _model.Solver.Assert(ctx.MkEq(_numValue, _model.Context.MkInt(((long)value.Number * Number.Scale).ToString(CultureInfo.InvariantCulture))));
                     return;
 
                 case Type.String:
@@ -493,7 +493,7 @@ ModelVariable GetOrCreateVar(BaseExpression sub)
             if (sub is ConstantNumber num)
             {
                 var n = _model.GetOrCreateVariable(new VariableName(Guid.NewGuid().ToString()));
-                n.AssertEq(num.Value.Value);
+                n.AssertEq(num.Value);
                 return n;
             }
 
@@ -536,7 +536,7 @@ public bool CanBeValue(Value v)
                 return _model.Solver.IsSatisfiable(
                     ctx.MkAnd(
                         ctx.MkEq(_type, _model.NumType),
-                        ctx.MkEq(_numValue, _model.Context.MkInt((v.Number.Value * Number.Scale).ToString()))
+                        ctx.MkEq(_numValue, _model.Context.MkInt(((long)v.Number * Number.Scale).ToString()))
                     )
                 );
             }
@@ -554,7 +554,7 @@ public bool CannotBeOtherValue(Value v)
                 return !_model.Solver.IsSatisfiable(ctx.MkNot(ctx.MkEq(_strValue, _model.Context.MkString(v.String))));
 
             if (v.Type == Type.Number)
-                return !_model.Solver.IsSatisfiable(ctx.MkNot(ctx.MkEq(_numValue, _model.Context.MkInt((v.Number.Value * Number.Scale).ToString()))));
+                return !_model.Solver.IsSatisfiable(ctx.MkNot(ctx.MkEq(_numValue, _model.Context.MkInt(((long)v.Number * Number.Scale).ToString()))));
 
             throw new NotSupportedException($"unknown value type {v.Type}");
         }

Yolol.Analysis/TreeVisitor/Reduction/ConstantCompressor.cs

@@ -65,7 +65,7 @@ void Submit(BaseExpression exp)
                 var b = idx / 10m;
                 try
                 {
-                    var log = Math.Log((double)value.Value, (double)b);
+                    var log = Math.Log((double)(decimal)value, (double)b);
                     if (double.IsNaN(log))
                         continue;
 
@@ -146,10 +146,10 @@ private static BaseExpression BestFraction(Number number)
                 }
             }
 
-            if (number.Value >= 1)
+            if (number >= 1)
                 return new ConstantNumber(number);
 
-            var (fn, fd) = RealToFraction((double)number.Value, 0.001f);
+            var (fn, fd) = RealToFraction((double)number, 0.001f);
 
             var replacement = new Divide(new ConstantNumber((decimal)fn), new ConstantNumber((decimal)fd));
 
@@ -164,7 +164,7 @@ private static BaseExpression BestFraction(Number number)
             var atan = new ArcTan(new ConstantNumber(number)).TryStaticEvaluate();
             if (!atan.HasValue)
                 return null;
-            var atanFloor = (long)atan.Value.Number.Value;
+            var atanFloor = (long)(decimal)atan.Value.Number;
 
             var offset = number - atan.Value;
 

Yolol.Analysis/TreeVisitor/Reduction/OpNumByConstNumCompressor.cs

@@ -27,7 +27,7 @@ protected override BaseExpression Visit(Multiply mul)
         {
             BaseExpression? HandleSingleSideNumber(Number number, BaseExpression other)
             {
-                return number.Value switch {
+                return (long)number switch {
                     -1 => base.Visit(new Negate(new Bracketed(other))),
                     0 => new ConstantNumber(0),
                     1 => base.Visit(other),
@@ -86,7 +86,7 @@ protected override BaseExpression Visit(Divide div)
             if (!rv.HasValue)
                 return base.Visit(div);
 
-            return rv.Value.Value switch {
+            return (long)rv.Value switch {
                 -1 => base.Visit(new Negate(new Bracketed(base.Visit(div.Left)))),
                 0 => new ErrorExpression(),
                 1 => base.Visit(new Bracketed(base.Visit(div.Left))),
@@ -98,7 +98,7 @@ protected override BaseExpression Visit(Add add)
         {
             BaseExpression? HandleSingleSideNumber(Number number, BaseExpression other)
             {
-                return number.Value switch
+                return (long)number switch
                 {
                     0 => base.Visit(new Bracketed(other)),
                     _ => null,
@@ -149,7 +149,7 @@ protected override BaseExpression Visit(Exponent exp)
             if (!rv.HasValue)
                 return base.Visit(exp);
 
-            return rv.Value.Value switch {
+            return (long)rv.Value switch {
                 0 => base.Visit(new ConstantNumber(1)),
                 1 => base.Visit(new Bracketed(base.Visit(exp.Left))),
                 -1 => base.Visit(new Divide(new ConstantNumber(1), new Bracketed(exp.Left))),

Yolol.Cylon/JSON/YololValueConverter.cs

@@ -13,7 +13,7 @@ public override void WriteJson(JsonWriter writer, Value value, JsonSerializer se
             if (value.Type == Execution.Type.String)
                 writer.WriteValue(value.String);
             else
-                writer.WriteValue(value.Number.Value);
+                writer.WriteValue((decimal)value.Number);
         }
 
         public override Value ReadJson(JsonReader reader, Type objectType, Value existingValue, bool hasExistingValue, JsonSerializer serializer)

Yolol/Execution/Number.cs

@@ -3,60 +3,27 @@
 
 namespace Yolol.Execution
 {
-    public struct Number
+    public readonly struct Number
         : IEquatable<Number>
     {
         public const int Scale = 1000;
         public const int Decimals = 3;
 
-        public static readonly Number MinValue = new Number(-9223372036854775.808m);
-        public static readonly Number MaxValue = new Number(9223372036854775.807m);
-        public static readonly Number One = new Number(1);
+        public static readonly Number MinValue = new Number(long.MinValue);
+        public static readonly Number MaxValue = new Number(long.MaxValue);
+        public static readonly Number One = new Number(1000);
         public static readonly Number Zero = new Number(0);
 
-        public decimal Value { get; }
+        private long Value { get; }
 
-        private Number(decimal num)
+        private Number(long num)
         {
             Value = num;
         }
 
-        private Number Truncate()
-        {
-            var d = Value;
-
-            // https://stackoverflow.com/a/43639947/108234
-            var r = Math.Round(d, Decimals);
-            if (d > 0 && r > d)
-                return new Number(r - new decimal(1, 0, 0, false, Decimals));
-            else if (d < 0 && r < d)
-                return new Number(r + new decimal(1, 0, 0, false, Decimals));
-
-            return new Number(r);
-
-            // Naieve approach
-            //return new Number(Math.Truncate(Value * Scale) / Scale);
-        }
-
-        private Number RangeCheck()
-        {
-            if (Value > MaxValue.Value)
-                return MaxValue;
-
-            if (Value < MinValue.Value)
-                return MinValue;
-
-            return this;
-        }
-
-        private static Number SafeNew(decimal num)
-        {
-            return new Number(num).Truncate().RangeCheck();
-        }
-
         public string ToString(CultureInfo culture)
         {
-            return Value.ToString("0.###", culture);
+            return ((decimal)Value / Scale).ToString(culture);
         }
 
         public override string ToString()
@@ -66,7 +33,7 @@ public override string ToString()
 
         public bool Equals(Number other)
         {
-            return this == other;
+            return Value == other.Value;
         }
 
         public override bool Equals(object obj)
@@ -81,64 +48,89 @@ public override int GetHashCode()
 
         public static Number Parse(string s)
         {
-            // First check if the number is so colossal that a decimal can't hold it
+            // First check if the number is out of the valid range
             var d = double.Parse(s);
-            if (d >= (double)MaxValue.Value)
+            if (d >= MaxValue.Value)
                 return MaxValue;
-            else if (d <= (double)MinValue.Value)
+            else if (d <= MinValue.Value)
                 return MinValue;
 
-            // It's within the safe range, parse as decimal
-            return SafeNew(decimal.Parse(s));
+            return decimal.Parse(s);
         }
 
         public static implicit operator Number(int i)
         {
-            return new Number(i);
+            return new Number(i * (long)Scale);
         }
 
         public static explicit operator Number(double i)
         {
-            return SafeNew((decimal)i);
+            var n = i * Scale;
+            if (n > MaxValue.Value)
+                return MaxValue;
+            if (n < MinValue.Value)
+                return MinValue;
+
+            return new Number((long)n);
         }
 
         public static implicit operator Number(decimal d)
         {
-            return SafeNew(d);
+            var n = d * Scale;
+            if (n > MaxValue.Value)
+                return MaxValue;
+            if (n < MinValue.Value)
+                return MinValue;
+
+            return new Number((long)(d * Scale));
+        }
+
+        public static explicit operator decimal(Number n)
+        {
+            return ((decimal)n.Value) / Scale;
+        }
+
+        public static explicit operator int(Number n)
+        {
+            return (int)(n.Value / Scale);
+        }
+
+        public static explicit operator float(Number n)
+        {
+            return ((float)n.Value) / Scale;
         }
 
         public static Number operator %(Number l, Number r)
         {
-            var v = new Number(l.Value % r.Value);
-            return v.Truncate();
+            return new Number(l.Value % r.Value);
         }
 
         public static Number operator *(Number l, Number r)
         {
-            return SafeNew(l.Value * r.Value);
+            return new Number((l.Value * r.Value) / Scale);
         }
 
         public static Number operator /(Number l, Number r)
         {
             if (r == Zero)
                 throw new ExecutionException("Divide by zero");
 
-            return SafeNew(l.Value / r.Value);
+            return new Number((l.Value * Scale) / r.Value);
         }
 
         public static Number operator +(Number l, Number r)
         {
-            return SafeNew(l.Value + r.Value);
+            return new Number(l.Value + r.Value);
         }
 
         public static Number operator -(Number l, Number r)
         {
-            return SafeNew(l.Value - r.Value);
+            return new Number(l.Value - r.Value);
         }
 
         public static Number operator -(Number n)
         {
-            return new Number(-n.Value).RangeCheck();
+            return new Number(-n.Value);
         }
 
         public static bool operator >(Number l, Number r)