Added engine.

Makefile

@@ -1,18 +1,29 @@
-test: test_neural test_persist test_lern
+test: test_neural test_persist test_lern test_engine
 
 test_persist:
-	@( cd persist && go test )
+	@( go test ./persist/ )
 
 test_neural:
 	@( go test )
 
-
 test_lern:
-	@( cd lern && go test )
+	@( go test ./lern/ )
+
+test_engine:
+	@( go test ./engine/ )
 
 goget:
 	@( \
 		go get github.com/NOX73/go-neural; \
 		go get github.com/NOX73/go-neural/persist; \
 		go get github.com/NOX73/go-neural/lern; \
+		go get github.com/NOX73/go-neural/engine; \
+	)
+
+gogetu:
+	@( \
+		go get -u github.com/NOX73/go-neural; \
+		go get -u github.com/NOX73/go-neural/persist; \
+		go get -u github.com/NOX73/go-neural/lern; \
+		go get -u github.com/NOX73/go-neural/engine; \
 	)

engine/engine.go

@@ -0,0 +1,109 @@
+package engine
+
+import (
+	"github.com/NOX73/go-neural"
+	"github.com/NOX73/go-neural/lern"
+	"github.com/NOX73/go-neural/persist"
+)
+
+const (
+	lernChannelCapacity = 5
+	calcChannelCapacity = 5
+	dumpChannelCapacity = 5
+)
+
+type Engine interface {
+	Start()
+	Lern(in, ideal []float64, speed float64)
+	Calculate([]float64) []float64
+	Dump() *persist.NetworkDump
+}
+
+type engine struct {
+	Network          *neural.Network
+	LernChannel      chan *request
+	CalculateChannel chan *request
+	DumpChannel      chan *request
+}
+
+type request []interface{}
+
+func New(n *neural.Network) Engine {
+	e := &engine{
+		Network:          n,
+		LernChannel:      make(chan *request, lernChannelCapacity),
+		CalculateChannel: make(chan *request, calcChannelCapacity),
+		DumpChannel:      make(chan *request, dumpChannelCapacity),
+	}
+
+	return e
+}
+
+func (e *engine) Start() {
+	go e.loop()
+}
+
+func (e *engine) Lern(in, ideal []float64, speed float64) {
+	e.LernChannel <- &request{&in, &ideal, speed}
+}
+
+func (e *engine) Calculate(in []float64) []float64 {
+	resp := make(chan *[]float64, 1)
+	e.CalculateChannel <- &request{&in, resp}
+	return *(<-resp)
+}
+
+func (e *engine) Dump() *persist.NetworkDump {
+	resp := make(chan *persist.NetworkDump, 1)
+	e.DumpChannel <- &request{resp}
+	return <-resp
+}
+
+func (e *engine) loop() {
+	for {
+
+		select {
+		case r := <-e.CalculateChannel:
+			e.calculate(r)
+		case r := <-e.DumpChannel:
+			e.dump(r)
+		default:
+		}
+
+		select {
+		case r := <-e.DumpChannel:
+			e.dump(r)
+		case r := <-e.CalculateChannel:
+			e.calculate(r)
+		case r := <-e.LernChannel:
+			e.lern(r)
+		}
+
+	}
+}
+
+func (e *engine) lern(req *request) {
+	r := *req
+
+	in := r[0].(*[]float64)
+	ideal := r[1].(*[]float64)
+	speed := r[2].(float64)
+	lern.Lern(e.Network, *in, *ideal, speed)
+}
+
+func (e *engine) calculate(req *request) {
+	r := *req
+
+	in := r[0].(*[]float64)
+	resp := r[1].(chan *[]float64)
+
+	res := e.Network.Calculate(*in)
+	resp <- &(res)
+}
+
+func (e *engine) dump(req *request) {
+	r := *req
+	resp := r[0].(chan *persist.NetworkDump)
+
+	resp <- persist.ToDump(e.Network)
+}

engine/engine_test.go

@@ -0,0 +1,31 @@
+package engine
+
+import (
+	"github.com/NOX73/go-neural"
+	"github.com/NOX73/go-neural/persist"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestBasic(t *testing.T) {
+	network := neural.NewNetwork(2, []int{2, 2})
+	engine := New(network)
+	engine.Start()
+
+	engine.Lern([]float64{1, 2}, []float64{3, 3}, 0.1)
+
+	out := engine.Calculate([]float64{1, 2})
+
+	assert.Equal(t, len(out), 2)
+}
+
+func TestDump(t *testing.T) {
+	network := neural.NewNetwork(3, []int{3, 3})
+	engine := New(network)
+	engine.Start()
+
+	dump := persist.ToDump(network)
+	dumpEng := engine.Dump()
+
+	assert.Equal(t, dump.Enters, dumpEng.Enters)
+}