Gul Banana fucked around with this message at 02:21 on Feb 1, 2015

Gul Banana fucked around with this message at 02:48 on Feb 1, 2015

    class FormulaTester
    {
        public void Test(IFormula f)
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("{0}({1}): {2}", f.Name, i, f.Calculate(i));
            }
        }
    }

    interface IFormula
    {
        string Name { get; }
        int Calculate(int i);
    }

    class DelegateFormula : IFormula
    {
        private string n;
        private Func<int, int> f;

        public DelegateFormula(string n, Func<int,int> f)
        {
            this.n = n;
            this.f = f;
        }

        public string Name
        {
            get { return n; }
        }

        public int Calculate(int i)
        {
            return f(i);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var tester = new FormulaTester();

            var changeAmount = 1;
            tester.Test(new DelegateFormula("inc", x => x + changeAmount));
            tester.Test(new DelegateFormula("dec", x => x - changeAmount));
            tester.Test(new DelegateFormula("const", x => changeAmount));

            Console.ReadKey();
        }
    }

    class FormulaTester
    {
        public void Test<T>(IFormula<T> f, T[] testdata)
        {
            foreach (var datum in testdata)
            {
                Console.WriteLine("{0}({1}): {2}", f.Name, datum, f.Calculate(datum));
            }
        }
    }

    interface IFormula<T>
    {
        string Name { get; }
        T Calculate(T i);
    }

    class DelegateFormula<T> : IFormula<T>
    {
        private string n;
        private Func<T, T> f;

        public DelegateFormula(string n, Func<T,T> f)
        {
            this.n = n;
            this.f = f;
        }

        public string Name
        {
            get { return n; }
        }

        public T Calculate(T x)
        {
            return f(x);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var tester = new FormulaTester();
            var data = new[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

            var changeAmount = 1;
            tester.Test(new DelegateFormula<int>("inc", x => x + changeAmount), data);
            tester.Test(new DelegateFormula<int>("dec", x => x - changeAmount), data);
            tester.Test(new DelegateFormula<int>("const", x => changeAmount), data);

            Console.ReadKey();
        }
    }

Gul Banana fucked around with this message at 09:12 on May 11, 2015

    class Box<T>
    {
        public T x {get; set;}

        public override string ToString()
        {
            return x.ToString();
        }
    }

    class FormulaTester
    {
        public void Test(IConcurrentFormula f)
        {
            var i0 = new Box<int> { x = 0 }; var i1 = new Box<int> { x = 1 };
            Console.WriteLine("{0}(0, 1): {1}", f.Name, f.Calculate(i0, i1));
            Console.WriteLine("{0}(1, 1): {1}", f.Name, f.Calculate(i1, i1));

            var d0 = new Box<double> { x = 0 }; var d1 = new Box<double> { x = 0 };
            Console.WriteLine("{0}(0.0, 1.0): {1}", f.Name, f.Calculate(d0, d1));
            Console.WriteLine("{0}(1.0, 1.0): {1}", f.Name, f.Calculate(d1, d1));

            var c0 = new Box<char> { x = '0' }; var c1 = new Box<char> { x = '1' };
            Console.WriteLine("{0}('0', '1'): {1}", f.Name, f.Calculate(i0, i1));
            Console.WriteLine("{0}('1', '1'): {1}", f.Name, f.Calculate(i1, i1));
        }
    }

    interface IConcurrentFormula
    {
        string Name { get; }
        T Calculate<T>(T left, T right) where T:class;
    }

    class SwapFormula : IConcurrentFormula
    {
        public string Name
        {
            get { return "swap"; }
        }

        public T Calculate<T>(T left, T right) where T : class
        {
            return Interlocked.Exchange(ref left, right);
        }
    }

    class CompareAndSwapFormula : IConcurrentFormula
    {
        public string Name
        {
            get { return "cas"; }
        }

        public T Calculate<T>(T left, T right) where T : class
        {
            Interlocked.CompareExchange<T>(ref left, default(T), right);
            return left;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var tester = new FormulaTester();
            
            tester.Test(new SwapFormula());
            tester.Test(new CompareAndSwapFormula());

            Console.ReadKey();
        }
    }

    class DelegateConcurrentFormula : IConcurrentFormula
    {
        private string n;
        private ??? f;

        public DelegateFormula(string n, ??? f)
        {
            this.n = n;
            this.f = f;
        }

        public string Name
        {
            get { return n; }
        }

        public T Calculate<T>(T left, T right) where T : class
        {
 	        return f<T>(left, right);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var tester = new FormulaTester();
            
            tester.Test(new DelegateConcurrentFormula("swap", (left, right) => Interlocked.Exchange(ref left, right)));
            tester.Test(new DelegateConcurrentFormula("cas", (left, right) => Interlocked.CompareExchange(ref left, right, right)));

            Console.ReadKey();
        }
    }

Gul Banana fucked around with this message at 09:12 on May 11, 2015