update to more modern java

Author: monkstone

xor/Rakefile

@@ -16,7 +16,7 @@ end
 
 desc 'Run'
 task :run do
-  sh 'k9 run xor.rb'
+  sh 'jruby xor.rb'
 end
 
 desc 'clean'

xor/ext/nn/Connection.java

@@ -8,8 +8,8 @@
 
 public class Connection {
 
-    private Neuron from;     // Connection goes from. . .
-    private Neuron to;       // To. . .
+    private final Neuron from;     // Connection goes from. . .
+    private final Neuron to;       // To. . .
     private float weight;   // Weight of the connection. . .
 
     // Constructor  builds a connection with a random weight

xor/ext/nn/Network.java

@@ -51,19 +51,19 @@ public Network(int inputs, int hiddentotal) {
         output = new OutputNeuron();
 
         // Connect input layer to hidden layer
-        for (int i = 0; i < input.length; i++) {
+        for (InputNeuron input1 : input) {
             for (int j = 0; j < hidden.length-1; j++) {
                 // Create the connection object and put it in both neurons
-                Connection c = new Connection(input[i],hidden[j]);
-                input[i].addConnection(c);
+                Connection c = new Connection(input1, hidden[j]);
+                input1.addConnection(c);
                 hidden[j].addConnection(c);
             }
         }
 
         // Connect the hidden layer to the output neuron
-        for (int i = 0; i < hidden.length; i++) {
-            Connection c = new Connection(hidden[i],output);
-            hidden[i].addConnection(c);
+        for (HiddenNeuron hidden1 : hidden) {
+            Connection c = new Connection(hidden1, output);
+            hidden1.addConnection(c);
             output.addConnection(c);
         }
 
@@ -105,20 +105,20 @@ public float train(float[] inputs, float answer) {
         for (int i = 0; i < connections.size(); i++) {
             Connection c = (Connection) connections.get(i);
             Neuron neuron = c.getFrom();
-            float output = neuron.getOutput();
-            float deltaWeight = output*deltaOutput;
+            float loutput = neuron.getOutput();
+            float deltaWeight = loutput*deltaOutput;
             c.adjustWeight(LEARNING_CONSTANT*deltaWeight);
         }
 
         // ADJUST HIDDEN WEIGHTS
-        for (int i = 0; i < hidden.length; i++) {
-            connections = hidden[i].getConnections();
+        for (HiddenNeuron hidden1 : hidden) {
+            connections = hidden1.getConnections();
             float sum  = 0;
             // Sum output delta * hidden layer connections (just one output)
             for (int j = 0; j < connections.size(); j++) {
                 Connection c = (Connection) connections.get(j);
                 // Is this a connection from hidden layer to next layer (output)?
-                if (c.getFrom() == hidden[i]) {
+                if (c.getFrom() == hidden1) {
                     sum += c.getWeight()*deltaOutput;
                 }
             }    
@@ -127,9 +127,9 @@ public float train(float[] inputs, float answer) {
             for (int j = 0; j < connections.size(); j++) {
                 Connection c = (Connection) connections.get(j);
                 // Is this a connection from previous layer (input) to hidden layer?
-                if (c.getTo() == hidden[i]) {
-                    float output = hidden[i].getOutput();
-                    float deltaHidden = output * (1 - output);  // Derivative of sigmoid(x)
+                if (c.getTo() == hidden1) {
+                    float loutput = hidden1.getOutput();
+                    float deltaHidden = loutput * (1 - loutput);  // Derivative of sigmoid(x)
                     deltaHidden *= sum;   // Would sum for all outputs if more than one output
                     Neuron neuron = c.getFrom();
                     float deltaWeight = neuron.getOutput()*deltaHidden;

xor/ext/nn/Neuron.java

@@ -12,21 +12,21 @@
 public class Neuron {
 
     protected float output;
-    protected ArrayList connections; 
+    protected ArrayList<Connection> connections; 
     protected boolean bias = false;
 
     // A regular Neuron
     public Neuron() {
         output = 0;
         // Using an arraylist to store list of connections to other neurons
-        connections = new ArrayList();  
+        connections = new ArrayList<>();  
         bias = false;
     }
 
     // Constructor for a bias neuron
     public Neuron(int i) {
         output = i;
-        connections = new ArrayList();
+        connections = new ArrayList<>();
         bias = true;
     }
 
@@ -37,10 +37,10 @@ public void calcOutput() {
             // do nothing
         } else {
             float sum = 0;
-            float bias = 0;
+            float lbias = 0;
             //System.out.println("Looking through " + connections.size() + " connections");
             for (int i = 0; i < connections.size(); i++) {
-                Connection c = (Connection) connections.get(i);
+                Connection c = connections.get(i);
                 Neuron from = c.getFrom();
                 Neuron to = c.getTo();
                 // Is this connection moving forward to us
@@ -49,14 +49,14 @@ public void calcOutput() {
                     // This isn't really necessary
                     // But I am treating the bias individually in case I need to at some point
                     if (from.bias) {
-                        bias = from.getOutput()*c.getWeight();
+                        lbias = from.getOutput()*c.getWeight();
                     } else {
                         sum += from.getOutput()*c.getWeight();
                     }
                 }
             }
             // Output is result of sigmoid function
-            output = f(bias+sum);
+            output = f(lbias+sum);
         }
     }
 
@@ -73,7 +73,7 @@ public static float f(float x) {
         return 1.0f / (1.0f + (float) Math.exp(-x));
     }
 
-    public ArrayList getConnections() {
+    public ArrayList<Connection> getConnections() {
         return connections;
     }