public void Algorithm()
        {
            // Nachbarschaft des ausgewählten Neurons: N+t
            Dictionary <Neuron, double> Neighborhood;

            // Zufällig durch die Input-Daten gehen
            IrisData = Shuffle(IrisData);

            foreach (IrisLib iris in IrisData)
            {
                // Rt: Adaptionsradius um das Gewinner-Neuron auf der Karte
                BlockRadius = BLOCK_RADIUS_START * Math.Pow((BLOCK_RADIUS_END / BLOCK_RADIUS_START), (Steps / STEPS_MAX));

                // Die zeitabhängige Lernrate εt
                LearningRate = LEARNING_RATE_START * Math.Pow((LEARNING_RATE_END / LEARNING_RATE_START), Steps / (STEPS_MAX));

                // Das Neuron mit der maximalen Erregung wird ermittelt. Minimaler Euklidischer Abstand zum Input-Vektor.
                Neuron closest = NeuronMap.OrderBy(n => (n.Position - iris.Position).Length).First();

                // Alle Nachbaren innerhalb des Blockradius des gewählten Neurons (inklusive selbst) auslesen.
                Neighborhood = closest.GetNeighborhood(BlockRadius);

                // Neuron und dessen Nachbarschaft ein Stück in die Richtung des Input-Vektors bewegen
                foreach (KeyValuePair <Neuron, double> n in Neighborhood)
                {
                    // Die zeitabhängige Entfernungsgewichtungsfunktion ht.
                    double weight = Math.Exp(-Math.Pow(n.Value / BlockRadius, 2));

                    n.Key.Position = n.Key.Position + LearningRate * weight * (iris.Position - n.Key.Position);
                }

                // Schrittzähler inkrementieren
                Steps++;
            }
        }
 public NeuronMapGenerator(int width, int height, int maxRooms, int roomMaxSize, int roomMinSize) : base(width, height)
 {
     _map         = new NeuronMap();
     _maxRooms    = maxRooms;
     _roomMaxSize = roomMaxSize;
     _roomMinSize = roomMinSize;
 }
        public void GenerateRegularMap(double width, double height, int size)
        {
            int    id         = 0;
            double step       = 300 / size;
            double leftOffset = (width / 2) - (size / 2) * step;
            double topOffset  = (height / 2) - (size / 2) * step;

            NeuronMap.Clear();

            for (int x = 0; x < size; x++)
            {
                for (int y = 0; y < size; y++)
                {
                    Neuron neuron = new Neuron(id, x * step + leftOffset, y * step + topOffset);
                    id++;
                    NeuronMap.Add(neuron);

                    if (y > 0 && y < size)
                    {
                        Neuron neighbor1 = NeuronMap.Where(n => n.Position.Y == neuron.Position.Y - step && n.Position.X == neuron.Position.X).FirstOrDefault();
                        neuron.AddAxon(180, neighbor1);
                    }

                    if (x > 0 && x < size)
                    {
                        Neuron neighbor2 = NeuronMap.Where(n => n.Position.Y == neuron.Position.Y && n.Position.X == neuron.Position.X - step).FirstOrDefault();
                        neuron.AddAxon(90, neighbor2);
                    }
                }
            }
        }