C#

double err=10, mmse ;
           int ss = data.GetLength(0);
           snetwork(0);
           initializes();
           mmse = 0;
           double mser=0.0;
         for (i = 0; i <iterasyon; i++)



           {


             mser = 0.0;
             for (int xx = 0; xx <data.GetLength(0); xx++)
             {


                 ffw(xx);
                 backpropagate(xx);
                 mser += mse(nb_cikis, xx);
             }

             mmse = mser / data.GetLength(0);
             if (mmse < 0.00001) break;
         } ;


           ffw_egitimout();

void  backpropagate(int r)
 {
            double sum;
            for (int j = 0; j < networks.layers[networks.layers.Length - 1].noron.Length; j++)
            {
                networks.layers[networks.layers.Length - 1].noron[j].hata = nb_cikis[r,j] - networks.layers[networks.layers.Length - 1].noron[j].output;
                networks.layers[networks.layers.Length - 1].noron[j].delta = networks.layers[networks.layers.Length - 1].noron[j].output * (1 - networks.layers[networks.layers.Length - 1].noron[j].output) * networks.layers[networks.layers.Length - 1].noron[j].hata;//son katman deltası hesaplanıyor...
            }

        	//	find delta for hidden layers	
	for(int i=networks.layers.Length-2;i>0;i--)
    {
		for(int j=0;j<networks.layers[i].noron.Length;j++)
        {
			sum=0.0;
             for (int k = 0; k < networks.layers[i].noron[j].sbaglanti.Length; k++)
            {
			             
          sum+=  networks.layers[laybul(networks.layers[i].noron[j].sbaglanti[k])].noron[nronbul(networks.layers[i].noron[j].sbaglanti[k])].delta*networks.layers[laybul(networks.layers[i].noron[j].sbaglanti[k])].noron[nronbul(networks.layers[i].noron[j].sbaglanti[k])].dentw[k];
				
			}
			networks.layers[i].noron[j].delta=networks.layers[i].noron[j].output*(1-networks.layers[i].noron[j].output)*sum;
//          
		}
	}
        
        

            	//	apply momentum ( does nothing if alpha=0 )

		for(int i=1;i<networks.layers.Length;i++)
        {
		
            for(int j=0;j<networks.layers[i].noron.Length;j++)
            {
			
                     for (int k = 0; k < networks.layers[i].noron[j].obaglanti.Length; k++)
                     {  
                         networks.layers[i].noron[j].dentw[k]+=momentum* networks.layers[i].noron[j].prew[k];
                   	
		     
			         }
              networks.layers[i].noron[j].bias+=momentum* networks.layers[i].noron[j].prewbias;
		    }
	    }

	//	adjust weights usng steepest descent	

		for(int i=1;i<networks.layers.Length;i++)
        {
	
            for(int j=0;j<networks.layers[i].noron.Length;j++)
            {
		
                     for (int k = 0; k < networks.layers[i].noron[j].obaglanti.Length; k++)
                     {
				        networks.layers[i].noron[j].prew[k]=Lr*networks.layers[i].noron[j].delta*networks.layers[laybul(networks.layers[i].noron[j].obaglanti[k])].noron[nronbul(networks.layers[i].noron[j].obaglanti[k])].output;

				        networks.layers[i].noron[j].dentw[k]+=networks.layers[i].noron[j].prew[k];
                   
			         }
                networks.layers[i].noron[j].prewbias=Lr*networks.layers[i].noron[j].delta;
			         
                networks.layers[i].noron[j].bias+=networks.layers[i].noron[j].prewbias;

		    }
        
        }
        
        
        
    }//function backprob. end

void ffw(int v)
       {

           double ssum,ssum1;

            for (int n = 0; n < networks.layers[0].noron.Length; n++)//n. neuron
               {
                 networks.layers[0].noron[n].output = ndata[v,n];//
               }


           for (int l = 1; l < networks.layers.Length; l++)//l. layer
           {
               for (int n = 0; n < networks.layers[l].noron.Length; n++)//n. neuron
               {
                   ssum = 0.0;

                   for(int k=0;k<networks.layers[l].noron[n].obaglanti.Length;k++)
                   {

                        ssum+= networks.layers[laybul(networks.layers[l].noron[n].obaglanti[k])].noron[nronbul(networks.layers[l].noron[n].obaglanti[k])].output*networks.layers[l].noron[n].dentw[k];

                         // Apply weight to inputs and add to sum
                   }
                 ssum+=networks.layers[l].noron[n].bias;        // Apply bias
               networks.layers[l].noron[n].output=activation(ssum);    //sigmoid function apply

               }// for n

           }// for l





       }

 class neuron
        {
            public double[] dentw,prew;
            public double prewbias,bias, hata, delta;

            public double[] input;
            public double output;
            public int[] sbaglanti;
            public int[] sbagk;
            public int[] obaglanti;
            public int numara;
            public int lay;
            public int nn;
            public int dents;//dentrit sayısı
            public int oid, sid;

            public neuron(int onron, int snron)
            {
                dentw = new double[onron];
                prew = new double[onron];
                input = new double[onron];
                sbaglanti = new int[snron];
                sbagk = new int[snron];
                obaglanti = new int[onron];
                oid = onron;
                sid = snron;
                dents = onron;
            }



        }




        class layer
        {
            public neuron[] noron;

            public layer()
            {
                noron = new neuron[nron];

                for (int index = 0; index < noron.Length; index++)
                {

                    noron[index] = new neuron(nron, nron);


                }
            }

            public layer(int neurons, int sneurons, int kendi)
            {
                noron = new neuron[kendi];

                for (int index = 0; index < noron.Length; index++)
                {
                    noron[index] = new neuron(neurons, sneurons);
                }
            }




        }//layer class

        class net
        {

            public int ban, hen;
            public layer[] layers;

            public net()
            {
                layers = new layer[lay];

                for (int index = 0; index < layers.Length; index++)
                {
                    layers[index] = new layer();
                }
            }


            public net(int lays, int[] neuronMap)
            {
                layers = new layer[lays];

                for (int index = (layers.Length - 1); index >= 0; index--)
                {
                    if (index == 0)
                        layers[index] = new layer(1, neuronMap[index + 1], neuronMap[index]);
                    else if (index == layers.Length - 1)
                        layers[index] = new layer(neuronMap[index - 1], 1, neuronMap[index]);
                    else
                        layers[index] = new layer(neuronMap[index - 1], neuronMap[index + 1], neuronMap[index]);
                }
            }


        } //net classs

#endregion


        static int[] neuronMap = new int[] { 5, 10,10, 5 };

        net networks = new net(neuronMap.Length, neuronMap);