ajpinedam · October 6, 2024 22:38 · Mar 6, 2019
diff --git a/Calculator.cs b/Calculator.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+namespace OperatorTest {
+    public interface ICalculator { }
+
+    public interface ICalculator<T> : ICalculator {
+        T Add(T a, T b);
+        T Divide(T a, T b);
+        T Multiply(T a, T b);
+        T Subtract(T a, T b);
+    }
+
+    static class Calculators {
+        public static readonly Dictionary<Type, ICalculator> calculators = new Dictionary<Type, ICalculator>() {
+            { typeof(int), new IntCalculator() },
+            { typeof(double), new DoubleCalculator() }
+        };
+
+        public static ICalculator<T> GetInstance<T>() {
+            return (ICalculator<T>) calculators[typeof(T)];
+        }
+    }
+
+    class IntCalculator : ICalculator<int> {
+        public int Add(int a, int b) { return a + b; }
+        public int Divide(int a, int b) { return a / b; }
+        public int Multiply(int a, int b) { return a * b; }
+        public int Subtract(int a, int b) { return a - b; }
+    }
+
+    class DoubleCalculator : ICalculator<double> {
+        public double Add(double a, double b) { return a + b; }
+        public double Divide(double a, double b) { return a / b; }
+        public double Multiply(double a, double b) { return a * b; }
+        public double Subtract(double a, double b) { return a - b; }
+    }
+}
diff --git a/Matrix.cs b/Matrix.cs
@@ -0,0 +1,45 @@
+using System;
+
+namespace OperatorTest {
+    public class Matrix<T> {
+        private static readonly ICalculator<T> calculator = Calculators.GetInstance<T>();
+        private readonly int w;
+        private readonly int h;
+        private readonly T[] values;
+
+        public Matrix(int w, int h) {
+            this.w = w;
+            this.h = h;
+            this.values = new T[w * h];
+        }
+
+        public T this[int i, int j] {
+            get { return values[i * w + j]; }
+            set { values[i * w + j] = value; }
+        }
+
+        public static Matrix<T> operator +(Matrix<T> a, Matrix<T> b) {
+            if (a.w != b.w || a.h != b.h) throw new ArgumentException("Matrices must have compatible dimensions");
+
+            var ret = new Matrix<T>(a.w, a.h);
+
+            for (int i = 0; i < a.values.Length; i++) {
+                ret.values[i] = calculator.Add(a.values[i], b.values[i]);
+            }
+
+            return ret;
+        }
+
+        public override string ToString() {
+            var sb = new System.Text.StringBuilder();
+            for (int i = 0; i < h; i++) {
+                if (i != 0) sb.Append("\n ");
+                for (int j = 0; j < w; j++) {
+                    if (j != 0) sb.Append(", ");
+                    sb.Append(this[i, j]);
+                }
+            }
+            return $"{{{sb}}}";
+        }
+    }
+}