Neural network.

enter.go

@@ -0,0 +1,27 @@
+package go_neural
+
+import "math/rand"
+
+type Enter struct {
+  Synapses    []*Synapse
+  Input       float64
+}
+
+func NewEnter () *Enter {
+  return &Enter{}
+}
+
+func ( e *Enter ) SynapseTo ( nTo *Neuron, weight float64 ) {
+  syn := NewSynapse( nTo, weight )
+  e.Synapses = append( e.Synapses, syn )
+}
+
+func ( e *Enter ) SetInput ( val float64 ) {
+  e.Input = val
+}
+
+func ( e *Enter ) ConnectTo ( layer *Layer ) {
+  for _, n := range layer.Neurons {
+    e.SynapseTo(n, rand.Float64()*0.1 )
+  }
+}

layer.go

@@ -2,9 +2,9 @@ package go_neural
 
 import "math/rand"
 
-func NewLayer (neurons int) *Layer {
+func NewLayer ( neurons int ) *Layer {
   l := &Layer{}
-  l.init(neurons)
+  l.init( neurons )
   return l
 }
 
@@ -20,7 +20,7 @@ func ( l *Layer ) ConnectTo ( layer *Layer ) {
   }
 }
 
-func ( l *Layer ) init (neurons int) {
+func ( l *Layer ) init ( neurons int ) {
   for ;neurons > 0; neurons-- { l.addNeuron() }
 }
 

network.go

@@ -1,9 +1,48 @@
 package go_neural
 
-func NewNetwork(in, out, layers int) *Network {
-  return &Network{}
+func NewNetwork(in int, layers []int) *Network {
+  n := &Network{
+    make([]*Enter, 0, in),
+    make([]*Layer, 0, len(layers)),
+  }
+  n.init(in, layers)
+  return n
 }
 
 type Network struct {
+  Enters      []*Enter
   Layers      []*Layer
 }
+
+func ( n *Network ) init (in int, layers []int) {
+  n.initLayers(layers)
+  n.initEnters(in)
+  n.connectLayers()
+  n.connectEnters()
+}
+
+func ( n *Network ) initLayers (layers []int) {
+  for _, count := range layers {
+    layer := NewLayer( count )
+    n.Layers = append(n.Layers, layer)
+  }
+}
+
+func ( n *Network ) initEnters (in int) {
+  for ;in > 0; in-- {
+    e := NewEnter()
+    n.Enters = append(n.Enters, e)
+  }
+}
+
+func ( n *Network ) connectLayers () {
+  for i := len(n.Layers) - 1;i > 0;i-- {
+    n.Layers[i-1].ConnectTo( n.Layers[i] )
+  }
+}
+
+func ( n *Network ) connectEnters () {
+  for _, e := range n.Enters {
+    e.ConnectTo( n.Layers[0] )
+  }
+}

network_test.go

@@ -0,0 +1,21 @@
+package go_neural
+
+import (
+  . "launchpad.net/gocheck"
+  //"log"
+)
+
+func ( s *SuiteT ) TestCreateNewNetwork (c *C) {
+  net := NewNetwork(10, []int{5,6,2})
+
+  c.Assert(len(net.Enters), Equals, 10)
+  c.Assert(len(net.Enters[0].Synapses), Equals, 5)
+
+  c.Assert(len(net.Layers), Equals, 3)
+  c.Assert(len(net.Layers[0].Neurons), Equals, 5)
+
+  c.Assert(len(net.Layers[0].Neurons[0].Synapses), Equals, 6)
+  c.Assert(len(net.Layers[1].Neurons[0].Synapses), Equals, 2)
+  c.Assert(len(net.Layers[2].Neurons[0].Synapses), Equals, 0)
+}
+

neuron.go

@@ -1,16 +1,16 @@
 package go_neural
 
-func NewNeuron () *Neuron {
-  return &Neuron{}
-}
-
 type Neuron struct {
   Synapses    []*Synapse
   Inputs      []float64
 }
 
-func ( n *Neuron ) SynapseTo ( neuron *Neuron, weight float64 ) {
-  syn := NewSynapse( neuron, weight )
+func NewNeuron () *Neuron {
+  return &Neuron{}
+}
+
+func ( n *Neuron ) SynapseTo ( nTo *Neuron, weight float64 ) {
+  syn := NewSynapse( nTo, weight )
   n.Synapses = append( n.Synapses, syn )
 }
 
@@ -21,3 +21,4 @@ func ( n *Neuron ) ResetInputs () {
 func ( n *Neuron ) AppendInput ( val float64 ) {
   n.Inputs = append( n.Inputs, val)
 }
+