Example neural network stuff

    abstract class BaseLayer
    {
        public int inputSize;
        public int outputSize;
        public float[] weight;

        public abstract void Init();
        public abstract float[] Compute(float[] input);
        public abstract float Activate(float input);
    }
    class Layer : BaseLayer
    {
        public Layer(int inputSize, int outputSize)
        {
            this.inputSize = inputSize;
            this.outputSize = outputSize;

            weight = new float[inputSize * outputSize];

            Init();
        }

        public override void Init()
        {
            Random rnd = new Random();

            for (int i = 0; i < weight.Length; i++)
            {
                weight[i] = (float)rnd.NextDouble();
            }
        }

        public override float[] Compute(float[] input)
        {
            float[] outputs = new float[outputSize];

            for (int i = 0; i < outputSize; i++)
            {
                float r = 0;

                for (int j = 0; j < inputSize; j++)
                {
                    r += input[j] * weight[i * inputSize + j];
                }

                outputs[i] = Activate(r);
            }

            return outputs;
        }

        public override float Activate(float input)
        {
            return 1 / (1 + (float)Math.Pow(Math.E, input));
        }
    }
    class Network
    {
        int inputSize;
        public List<BaseLayer> layers;

        public Network(int inputSize)
        {
            this.inputSize = inputSize;
            this.layers = new List<BaseLayer>();
        }

        public void AddLayer<T>(int size) where T : BaseLayer
        {
            if (layers.Count > 0)
            {
                layers.Add((T)Activator.CreateInstance(typeof(T), new object[] { layers.Last().outputSize, size}));
                return;
            }

            layers.Add((T)Activator.CreateInstance(typeof(T), new object[] { inputSize, size }));
        }

        public float[] Compute(float[] input)
        {
            float[] output = input;

            foreach(BaseLayer layer in layers)
            {
                output = layer.Compute(output);
            }

            return output;
        }
    }