Tensor arithmetic

Compiler/ILCompiler.Expressions.ComponentAccess.cs

@@ -40,15 +40,17 @@ static Type[] GetTypeArrayOfInt(int length)
         }
 
         public IlExpression ConvertToIlExpression(ComponentAccess expr,
-            NascentMethod nm, VariableIdentityMap variables)
+            NascentMethod nm, SolusEnvironment env,
+            VariableIdentityMap variables)
         {
-            var expr2 = ConvertToIlExpression(expr.Expr, nm, variables);
+            var expr2 = ConvertToIlExpression(expr.Expr, nm, env, variables);
             var indexes2 = new IlExpression[expr.Indexes.Count];
             int i;
             for (i = 0; i < indexes2.Length; i++)
             {
                 indexes2[i] = new ConvertI4IlExpression(
-                    ConvertToIlExpression(expr.Indexes[i], nm, variables));
+                    ConvertToIlExpression(expr.Indexes[i], nm, env,
+                        variables));
             }
 
             // TODO: check expr.ResultType against the number of indexes

Compiler/ILCompiler.Expressions.FunctionCall.cs

@@ -32,11 +32,12 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             FunctionCall expr, NascentMethod nm,
-            VariableIdentityMap variables)
+            SolusEnvironment env, VariableIdentityMap variables)
         {
             if (expr.Function is Literal literal &&
                 literal.Value is Function f)
-                return ConvertToIlExpression(f, nm, variables, expr.Arguments);
+                return ConvertToIlExpression(f, nm, env, variables,
+                    expr.Arguments);
 
             // TODO:
             throw new NotImplementedException(

Compiler/ILCompiler.Expressions.Literal.cs

@@ -31,7 +31,7 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             Literal expr, NascentMethod nm,
-            VariableIdentityMap variables)
+            SolusEnvironment env, VariableIdentityMap variables)
         {
             // TODO: work out how to use `variables` in place of null `env`
 

Compiler/ILCompiler.Expressions.MatrixExpression.cs

@@ -29,7 +29,8 @@ namespace MetaphysicsIndustries.Solus.Compiler
     public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(MatrixExpression expr,
-            NascentMethod nm, VariableIdentityMap variables)
+            NascentMethod nm, SolusEnvironment env,
+            VariableIdentityMap variables)
         {
             var arrayType = typeof(float[,]);
             var ctor = arrayType.GetConstructor(
@@ -51,7 +52,8 @@ public IlExpression ConvertToIlExpression(MatrixExpression expr,
                         dup,
                         new LoadConstantIlExpression(r),
                         new LoadConstantIlExpression(c),
-                        ConvertToIlExpression(expr[r, c], nm, variables)));
+                        ConvertToIlExpression(expr[r, c], nm, env,
+                            variables)));
             return new IlExpressionSequence(seq);
         }
     }

Compiler/ILCompiler.Expressions.VariableAccess.cs

@@ -30,7 +30,7 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             VariableAccess expr, NascentMethod nm,
-            VariableIdentityMap variables)
+            SolusEnvironment env, VariableIdentityMap variables)
         {
             var vi = variables[expr.VariableName];
             if (vi.Source == VariableSource.Param)

Compiler/ILCompiler.Expressions.VectorExpression.cs

@@ -29,7 +29,8 @@ namespace MetaphysicsIndustries.Solus.Compiler
     public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(VectorExpression expr,
-            NascentMethod nm, VariableIdentityMap variables)
+            NascentMethod nm, SolusEnvironment env,
+            VariableIdentityMap variables)
         {
             var seq = new List<IlExpression>();
             var newarr = new NewArrIlExpression(
@@ -42,7 +43,8 @@ public IlExpression ConvertToIlExpression(VectorExpression expr,
                     new StoreElemIlExpression(
                         array_: new DupIlExpression(newarr),
                         index: new LoadConstantIlExpression(i),
-                        value: ConvertToIlExpression(expr[i], nm, variables)));
+                        value: ConvertToIlExpression(expr[i], nm, env,
+                            variables)));
 
             return new IlExpressionSequence(seq);
         }

Compiler/ILCompiler.Expressions.cs

@@ -31,34 +31,37 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             Expression expr, NascentMethod nm,
-            VariableIdentityMap variables)
+            SolusEnvironment env, VariableIdentityMap variables)
         {
             if (expr is FunctionCall call)
-                return ConvertToIlExpression(call, nm, variables);
+                return ConvertToIlExpression(call, nm, env, variables);
             if (expr is Literal lit)
-                return ConvertToIlExpression(lit, nm, variables);
+                return ConvertToIlExpression(lit, nm, env, variables);
             if (expr is VariableAccess va)
-                return ConvertToIlExpression(va, nm, variables);
+                return ConvertToIlExpression(va, nm, env, variables);
             if (expr is ComponentAccess ca)
-                return ConvertToIlExpression(ca, nm, variables);
+                return ConvertToIlExpression(ca, nm, env, variables);
             if (expr is VectorExpression ve)
-                return ConvertToIlExpression(ve, nm, variables);
+                return ConvertToIlExpression(ve, nm, env, variables);
             if (expr is MatrixExpression me)
-                return ConvertToIlExpression(me, nm, variables);
+                return ConvertToIlExpression(me, nm, env, variables);
             if (expr is IntervalExpression ie)
-                return ConvertToIlExpression(ie, nm, variables);
+                return ConvertToIlExpression(ie, nm, env, variables);
             throw new ArgumentException(
                 $"Unsupported expression type: \"{expr}\"", nameof(expr));
         }
 
         // TODO: copy-paste IlCompiler.Expressions.*.cs here
 
         public IlExpression ConvertToIlExpression(IntervalExpression expr,
-            NascentMethod nm, VariableIdentityMap variables)
+            NascentMethod nm, SolusEnvironment env,
+            VariableIdentityMap variables)
         {
-            var lower = ConvertToIlExpression(expr.LowerBound, nm, variables);
+            var lower = ConvertToIlExpression(expr.LowerBound, nm, env,
+                variables);
             var isLowerOpen = new LoadConstantIlExpression(expr.OpenLowerBound);
-            var upper = ConvertToIlExpression(expr.UpperBound, nm, variables);
+            var upper = ConvertToIlExpression(expr.UpperBound, nm, env,
+                variables);
             var isUpperOpen = new LoadConstantIlExpression(expr.OpenUpperBound);
             // TODO: IsIntegerInterval ?
             var stuple = typeof(STuple<float, bool, float, bool>);

Compiler/ILCompiler.Functions.AbsoluteValueFunction.cs

@@ -32,12 +32,12 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             AbsoluteValueFunction func, NascentMethod nm,
-            VariableIdentityMap variables,
+            SolusEnvironment env, VariableIdentityMap variables,
             List<Expression> arguments)
         {
             return new CallIlExpression(
                 new Func<double, double>(Math.Abs),
-                ConvertToIlExpression(arguments[0], nm, variables));
+                ConvertToIlExpression(arguments[0], nm, env, variables));
         }
     }
 }

Compiler/ILCompiler.Functions.AdditionOperation.cs

@@ -22,43 +22,159 @@
 
 using System.Collections.Generic;
 using MetaphysicsIndustries.Solus.Compiler.IlExpressions;
+using MetaphysicsIndustries.Solus.Exceptions;
 using MetaphysicsIndustries.Solus.Expressions;
 using MetaphysicsIndustries.Solus.Functions;
+using MetaphysicsIndustries.Solus.Sets;
+using MetaphysicsIndustries.Solus.Values;
 
 namespace MetaphysicsIndustries.Solus.Compiler
 {
     public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             AdditionOperation func, NascentMethod nm,
-            VariableIdentityMap variables,
+            SolusEnvironment env, VariableIdentityMap variables,
             List<Expression> arguments)
         {
             IlExpression expr = new RawInstructions();
 
-            bool first = true;
-            foreach (var arg in arguments)
+            var argType = arguments[0].GetResultType(env);
+            if (argType.IsSubsetOf(Reals.Value)){
+                bool first = true;
+                foreach (var arg in arguments)
+                {
+                    if (!first &&
+                        arg is FunctionCall call &&
+                        call.Function is Literal literal &&
+                        literal.Value is Function f &&
+                        f == NegationOperation.Value)
+                    {
+                        expr = new SubIlExpression(expr,
+                            ConvertToIlExpression(call.Arguments[0], nm,
+                                env, variables));
+                    }
+                    else
+                    {
+                        if (first)
+                            expr = ConvertToIlExpression(arg, nm, env,
+                                variables);
+                        else
+                            expr = new AddIlExpression(expr,
+                                ConvertToIlExpression(arg, nm, env,
+                                    variables));
+                        first = false;
+                    }
+                }
+            }
+            else if (argType is Vectors vt)
             {
-                if (!first &&
-                    arg is FunctionCall call &&
-                    call.Function is Literal literal &&
-                    literal.Value is Function f &&
-                    f == NegationOperation.Value)
+                int n = vt.Dimension;
+                var seq = new List<IlExpression>();
+                var destLocal = nm.CreateLocal(typeof(float[]), "vectorSum");
+                var stloc = new StoreLocalIlExpression(
+                    destLocal,
+                    ConvertToIlExpression(
+                        new Literal(Vector.Zero(n)), nm, env, variables));
+                seq.Add(stloc);
+                var addendLocal =
+                    nm.CreateLocal(typeof(float[]), "vectorAddend");
+                foreach (var arg in arguments)
                 {
-                    expr = new SubIlExpression(expr,
-                        ConvertToIlExpression(call.Arguments[0], nm,
-                            variables));
+                    seq.Add(
+                        new StoreLocalIlExpression(
+                            addendLocal,
+                            ConvertToIlExpression(arg, nm, env, variables)));
+                    // TODO: logic to choose between a loop (e.g.
+                    //       WhileLoopConstruct) and a hard-coded sequence of
+                    //       instructions, or something in between, like a
+                    //       partially unrolled loop, or even a duff's device.
+                    int i;
+                    for (i = 0; i < n; i++)
+                        seq.Add(new StoreElemIlExpression(
+                            new LoadLocalIlExpression(destLocal),
+                            new LoadConstantIlExpression(i),
+                            new AddIlExpression(
+                                new LoadElemIlExpression(
+                                    new LoadLocalIlExpression(destLocal),
+                                    new LoadConstantIlExpression(i)),
+                                new LoadElemIlExpression(
+                                    new LoadLocalIlExpression(addendLocal),
+                                    new LoadConstantIlExpression(i)))));
                 }
-                else
+
+                seq.Add(new LoadLocalIlExpression(destLocal));
+
+                return new IlExpressionSequence(seq);
+            }
+            else if (argType is Matrices mt)
+            {
+                int nr = mt.RowCount;
+                int nc = mt.ColumnCount;
+                var seq = new List<IlExpression>();
+                var destLocal = nm.CreateLocal(typeof(float[]), "sum");
+                var stloc = new StoreLocalIlExpression(
+                    destLocal,
+                    ConvertToIlExpression(
+                        new Literal(Matrix.Zero(nr, nc)),
+                        nm, env, variables));
+                seq.Add(stloc);
+                var addendLocal =
+                    nm.CreateLocal(typeof(float[]), "addend");
+                foreach (var arg in arguments)
                 {
-                    if (first)
-                        expr = ConvertToIlExpression(arg, nm, variables);
-                    else
-                        expr = new AddIlExpression(expr,
-                            ConvertToIlExpression(arg, nm, variables));
-                    first = false;
+                    seq.Add(
+                        new StoreLocalIlExpression(
+                            addendLocal,
+                            ConvertToIlExpression(arg, nm, env, variables)));
+                    // TODO: logic to choose between loops (e.g.
+                    //       WhileLoopConstruct) and a hard-coded sequence of
+                    //       instructions, or something in between, like
+                    //       partially unrolled loops, or even duff's device.
+                    var arrayType = typeof(float[,]);
+                    var ctor = arrayType.GetConstructor(
+                        new[] { typeof(int), typeof(int) });
+                    var getMethod = arrayType.GetMethod("Get",
+                        new[] { typeof(int), typeof(int) });
+                    var setMethod = arrayType.GetMethod("Set",
+                        new[] { typeof(int), typeof(int), typeof(float) });
+                    var destIl = new LoadLocalIlExpression(destLocal);
+                    var addendIl = new LoadLocalIlExpression(addendLocal);
+                    int r, c;
+                    for (r = 0; r < nr; r++)
+                    {
+                        var ril = new LoadConstantIlExpression(r);
+                        for (c = 0; c < nc; c++)
+                        {
+                            var cil = new LoadConstantIlExpression(c);
+                            seq.Add(
+                                new CallIlExpression(
+                                    setMethod,
+                                    destIl,
+                                    ril,
+                                    cil,
+                                    new AddIlExpression(
+                                        new CallIlExpression(
+                                            getMethod,
+                                            destIl,
+                                            ril,
+                                            cil),
+                                        new CallIlExpression(
+                                            getMethod,
+                                            addendIl,
+                                            ril,
+                                            cil))));
+                        }
+                    }
                 }
+
+                seq.Add(new LoadLocalIlExpression(destLocal));
+
+                return new IlExpressionSequence(seq);
             }
+            else
+                throw new TypeException("argument at index 0",
+                    $"Unsupported type for addition: {argType.DisplayName}");
 
             return expr;
         }

Compiler/ILCompiler.Functions.ArccosecantFunction.cs

@@ -32,15 +32,15 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             ArccosecantFunction func, NascentMethod nm,
-            VariableIdentityMap variables,
+            SolusEnvironment env, VariableIdentityMap variables,
             List<Expression> arguments)
         {
             var expr = new CallIlExpression(
                 typeof(Math).GetMethod(
                     "Asin", new [] { typeof(float) }),
                 new DivIlExpression(
                     new LoadConstantIlExpression(1f),
-                    ConvertToIlExpression(arguments[0], nm, variables)));
+                    ConvertToIlExpression(arguments[0], nm, env, variables)));
             return expr;
         }
     }

Compiler/ILCompiler.Functions.ArccosineFunction.cs

@@ -33,7 +33,7 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             ArccosineFunction func, NascentMethod nm,
-            VariableIdentityMap variables,
+            SolusEnvironment env, VariableIdentityMap variables,
             List<Expression> arguments)
         {
             var excType = typeof(OperandException);
@@ -45,7 +45,7 @@ public IlExpression ConvertToIlExpression(
             var expr = new CallIlExpression(
                 new Func<double, double>(Math.Acos));
             var seq = new List<IlExpression>();
-            var arg = ConvertToIlExpression(arguments[0], nm, variables);
+            var arg = ConvertToIlExpression(arguments[0], nm, env, variables);
             seq.Add(arg);
             seq.Add(
                 new CompareLessThanIlExpression(

Compiler/ILCompiler.Functions.ArccotangentFunction.cs

@@ -32,13 +32,13 @@ public partial class ILCompiler
     {
         public IlExpression ConvertToIlExpression(
             ArccotangentFunction func, NascentMethod nm,
-            VariableIdentityMap variables,
+            SolusEnvironment env, VariableIdentityMap variables,
             List<Expression> arguments)
         {
             var expr = new CallIlExpression(
                 new Func<double, double, double>(Math.Atan2),
                 new LoadConstantIlExpression(1f),
-                ConvertToIlExpression(arguments[0], nm, variables));
+                ConvertToIlExpression(arguments[0], nm, env, variables));
             return expr;
         }
     }