remove pointless casting to float

Author: monkstone

nature-of-code/xor/pom.rb

@@ -28,5 +28,4 @@
     source_directory 'src'
     final_name 'xor'
   end
-
 end

nature-of-code/xor/pom.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+
+DO NOT MODIFIY - GENERATED CODE
+
+
+-->
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>nn</groupId>
+  <artifactId>xor</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <name>xor</name>
+  <description>neural net library for xor</description>
+  <developers>
+    <developer>
+      <id>shiffman</id>
+      <name>DanShiffman</name>
+      <roles>
+        <role>developer</role>
+      </roles>
+    </developer>
+  </developers>
+  <properties>
+    <polyglot.dump.pom>pom.xml</polyglot.dump.pom>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <xor.basedir>${project.basedir}</xor.basedir>
+  </properties>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <defaultGoal>package</defaultGoal>
+    <finalName>xor</finalName>
+    <pluginManagement>
+      <plugins>
+        <plugin>
+          <artifactId>maven-jar-plugin</artifactId>
+          <version>2.3.2</version>
+          <configuration>
+            <outputDirectory>${xor.basedir}/library/xor</outputDirectory>
+          </configuration>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
+</project>

nature-of-code/xor/src/nn/Connection.java

@@ -10,17 +10,17 @@ public class Connection {
 
     private final Neuron from;     // Connection goes from. . .
     private final Neuron to;       // To. . .
-    private float weight;   // Weight of the connection. . .
+    private double weight;   // Weight of the connection. . .
 
     // Constructor  builds a connection with a random weight
     public Connection(Neuron a_, Neuron b_) {
         from = a_;
         to = b_;
-        weight = (float) Math.random()*2-1;
+        weight = (double) Math.random()*2-1;
     }
 
     // In case I want to set the weights manually, using this for testing
-    public Connection(Neuron a_, Neuron b_, float w) {
+    public Connection(Neuron a_, Neuron b_, double w) {
         from = a_;
         to = b_;
         weight = w;
@@ -34,12 +34,12 @@ public Neuron getTo() {
         return to;
     }  
 
-    public float getWeight() {
+    public double getWeight() {
         return weight;
     }
 
     // Changing the weight of the connection
-    public void adjustWeight(float deltaWeight) {
+    public void adjustWeight(double deltaWeight) {
         weight += deltaWeight;
     }
 

nature-of-code/xor/src/nn/InputNeuron.java

@@ -16,7 +16,7 @@ public InputNeuron(int i) {
         super(i);
     }
 
-    public void input(float d) {
+    public void input(double d) {
         output = d;
     }
 

nature-of-code/xor/src/nn/Network.java

@@ -22,7 +22,7 @@ public class Network {
     HiddenNeuron[] hidden;
     OutputNeuron output;
 
-    public static final float LEARNING_CONSTANT = 0.5f;
+    public static final double LEARNING_CONSTANT = 0.5;
 
     // Only One output now to start!!! (i can do better, really. . .)
     // Constructor makes the entire network based on number of inputs & number of neurons in hidden layer
@@ -70,7 +70,7 @@ public Network(int inputs, int hiddentotal) {
     }
 
 
-    public float feedForward(float[] inputVals) {
+    public double feedForward(double[] inputVals) {
 
         // Feed the input with an array of inputs
         for (int i = 0; i < inputVals.length; i++) {
@@ -89,13 +89,13 @@ public float feedForward(float[] inputVals) {
         return output.getOutput();
     }
 
-    public float train(float[] inputs, float answer) {
-        float result = feedForward(inputs);
+    public double train(double[] inputs, double answer) {
+        double result = feedForward(inputs);
 
 
         // This is where the error correction all starts
         // Derivative of sigmoid output function * diff between known and guess
-        float deltaOutput = result*(1-result) * (answer-result);
+        double deltaOutput = result*(1-result) * (answer-result);
 
 
         // BACKPROPOGATION
@@ -105,15 +105,15 @@ 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 loutput = neuron.getOutput();
-            float deltaWeight = loutput*deltaOutput;
+            double loutput = neuron.getOutput();
+            double deltaWeight = loutput*deltaOutput;
             c.adjustWeight(LEARNING_CONSTANT*deltaWeight);
         }
 
         // ADJUST HIDDEN WEIGHTS
         for (HiddenNeuron hidden1 : hidden) {
             connections = hidden1.getConnections();
-            float sum  = 0;
+            double 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);
@@ -128,11 +128,11 @@ public float train(float[] inputs, float answer) {
                 Connection c = (Connection) connections.get(j);
                 // Is this a connection from previous layer (input) to hidden layer?
                 if (c.getTo() == hidden1) {
-                    float loutput = hidden1.getOutput();
-                    float deltaHidden = loutput * (1 - loutput);  // Derivative of sigmoid(x)
+                    double loutput = hidden1.getOutput();
+                    double 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;
+                    double deltaWeight = neuron.getOutput()*deltaHidden;
                     c.adjustWeight(LEARNING_CONSTANT*deltaWeight);
                 }
             } 

nature-of-code/xor/src/nn/Neuron.java

@@ -11,7 +11,7 @@
 
 public class Neuron {
 
-    protected float output;
+    protected double output;
     protected ArrayList<Connection> connections; 
     protected boolean bias = false;
 
@@ -36,8 +36,8 @@ public void calcOutput() {
         if (bias) {
             // do nothing
         } else {
-            float sum = 0;
-            float lbias = 0;
+            double sum = 0;
+            double lbias = 0;
             //System.out.println("Looking through " + connections.size() + " connections");
             for (int i = 0; i < connections.size(); i++) {
                 Connection c = connections.get(i);
@@ -64,13 +64,13 @@ void addConnection(Connection c) {
         connections.add(c);
     }
 
-    float getOutput() {
+    double getOutput() {
         return output;
     }
 
     // Sigmoid function
-    public static float f(float x) {
-        return 1.0f / (1.0f + (float) Math.exp(-x));
+    public static double f(double x) {
+        return 1.0 / (1.0 + Math.exp(-x));
     }
 
     public ArrayList<Connection> getConnections() {