using System;

using System.IO;

using System.Linq;

using System.Collections.Generic;

​

namespace CSharp_Shell

{

      public class NeuralNetwork 

      {

          public void Init(List<List<float>> inputs, List<List<float>> outputs, int extraCount, int extraSize) {

            int trainTimes = 20000;

            List<List<List<float>>> weights = new List<List<List<float>>>();

            int totalCount = extraCount + 1;

            List<int> totals = getCount(inputs[0], outputs[0], extraCount, extraSize);

            for(int a = 0; a < totalCount; a++) {

                weights.Add(new List<List<float>>());

                for(int b = 0; b < totals[a]; b++) {

                    weights[a].Add(new List<float>());

                    for(int c = 0; c < totals[a + 1]; c++) {

                        weights[a][b].Add(RandomValue(0, 10000, 10000f));

                    }

                }

            }

            List<float> outputsTemp = new List<float>();

            for(int q = 0; q < inputs.Count(); q++) {

               outputsTemp = InitOne(inputs[q], outputs[q], weights);

               foreach(float i in outputsTemp) Console.Write(i + " | ");

               Console.WriteLine();

               for(int j = 0; j < trainTimes; j++) {

                weights = BackProp(inputs[q], outputsTemp, outputs[q], weights);

                outputsTemp = InitOne(inputs[q], outputs[q], weights);

                if(outputsTemp == outputs[q]) {

                    j = trainTimes;

                }

               }

               Console.Write("# ");

               foreach(float i2 in outputsTemp) Console.Write(i2 + " | ");

               Console.WriteLine();

            }

            for(int u9 = 0; u9 < inputs.Count(); u9++) {

                outputsTemp = InitOne(inputs[u9], outputs[u9], weights);

                Console.Write("@ ");

                foreach(float i3 in outputsTemp) Console.Write(i3 + " | ");

                Console.WriteLine();

            }

          }

          public List<List<List<float>>> BackProp(List<float> inputs, List<float> outputsGot, List<float> outputsExpected, List<List<List<float>>> weights) {

          float diffrence = 0f;

          for(int a = 0; a < 1; a++) {

            for(int b = 0; b < weights[weights.Count() - (a + 1)].Count(); b++) {

                diffrence = outputsGot[b] - outputsExpected[b];

                for(int c = 0; c < weights[weights.Count() - (a + 1)][b].Count(); c++) {

                    weights[weights.Count() - (a + 1)][b][c] -= diffrence / weights[weights.Count() - (a + 1)][b].Count();

                    weights[weights.Count() - (a + 1)][b][c] = (float)Math.Round(weights[weights.Count() - (a + 1)][b][c] * 1000) / 1000f;

                }

                outputsGot = InitOne(inputs, outputsExpected, weights);

            }

          }

          return weights;

          }

          public List<float> InitOne(List<float> inputs, List<float> outputs, List<List<List<float>>> weights) {

            List<List<float>> inputsTemp = new List<List<float>>();

            //inputsTemp.Add(new List<float>());

            inputsTemp.Add(inputs);

            for(int a = 0; a < weights.Count(); a++) {

                List<float> resultTemp = new List<float>();

                inputsTemp.Add(new List<float>());

                for(int b = 0; b < weights[a].Count(); b++) {

                    float temoValue = 0f;

                    for(int c = 0; c < weights[a][b].Count(); c++) {

                        temoValue += inputsTemp[a][b] * weights[a][b][c];

                    }

                    resultTemp.Add(temoValue);

                }

                inputsTemp[a + 1] = resultTemp;

            }

            return inputsTemp[inputsTemp.Count() - 1];

          }

          public List<int> getCount(List<float> inputs, List<float> outputs, int eCount, int eSize) {

            List<int> l = new List<int>();

            l.Add(inputs.Count());

            for(int a = 0; a < eCount; a++) {

                l.Add(eSize);

            }

            l.Add(outputs.Count());

            return l;

          }

          public float RandomValue(int smallest, int highest, float by) {

            Random r = new Random();

            return r.Next(smallest, highest + 1) / by;

          }

      }

    public class Program : NeuralNetwork

    {

        public void Main() 

        {

             List<List<float>> inputs = new List<List<float>>();

             List<List<float>> outputs = new List<List<float>>();

             inputs.Add(new List<float>());

             outputs.Add(new List<float>());

             inputs[0].Add(0.1f);

             inputs[0].Add(0.2f);

             inputs[0].Add(0.3f);

             outputs[0].Add(0.3f);

             outputs[0].Add(0.2f);

             outputs[0].Add(0.1f);

             inputs.Add(new List<float>());

             outputs.Add(new List<float>());

             inputs[1].Add(0.5f);

             inputs[1].Add(0.4f);

             inputs[1].Add(0.6f);

             outputs[1].Add(0.6f);

             outputs[1].Add(0.4f);

             outputs[1].Add(0.5f);

             inputs.Add(new List<float>());

             outputs.Add(new List<float>());

             inputs[2].Add(0.9f);

             inputs[2].Add(0.5f);

             inputs[2].Add(0.3f);

             outputs[2].Add(0.3f);

             outputs[2].Add(0.5f);

             outputs[2].Add(0.9f);

           Init(inputs, outputs, 3, 3);

        }

    }

}