Formatting.

1 files changed, 36 insertions, 29 deletions

diff --git a/src/lib/src/neuralnet.c b/src/lib/src/neuralnet.c
index cac611a..a5fc59b 100644
--- a/src/lib/src/neuralnet.c
+++ b/src/lib/src/neuralnet.c
@@ -1,13 +1,14 @@
 #include <neuralnet/neuralnet.h>
 
-#include <neuralnet/matrix.h>
 #include "activation.h"
 #include "neuralnet_impl.h"
+#include <neuralnet/matrix.h>
 
 #include <assert.h>
 #include <stdlib.h>
 
-nnNeuralNetwork* nnMakeNet(int num_layers, const int* layer_sizes, const nnActivation* activations) {
+nnNeuralNetwork* nnMakeNet(
+    int num_layers, const int* layer_sizes, const nnActivation* activations) {
   assert(num_layers > 0);
   assert(layer_sizes);
   assert(activations);
@@ -19,10 +20,10 @@ nnNeuralNetwork* nnMakeNet(int num_layers, const int* layer_sizes, const nnActiv
 
   net->num_layers = num_layers;
 
-  net->weights = calloc(num_layers, sizeof(nnMatrix));
-  net->biases  = calloc(num_layers, sizeof(nnMatrix));
+  net->weights     = calloc(num_layers, sizeof(nnMatrix));
+  net->biases      = calloc(num_layers, sizeof(nnMatrix));
   net->activations = calloc(num_layers, sizeof(nnActivation));
-  if ( (net->weights == 0) || (net->biases == 0) || (net->activations == 0) ) {
+  if ((net->weights == 0) || (net->biases == 0) || (net->activations == 0)) {
     nnDeleteNet(&net);
     return 0;
   }
@@ -30,15 +31,15 @@ nnNeuralNetwork* nnMakeNet(int num_layers, const int* layer_sizes, const nnActiv
   for (int l = 0; l < num_layers; ++l) {
     // layer_sizes = { input layer size, first hidden layer size, ...}
     const int layer_input_size  = layer_sizes[l];
-    const int layer_output_size = layer_sizes[l+1];
+    const int layer_output_size = layer_sizes[l + 1];
 
     // We store the transpose of the weight matrix as written in textbooks.
     // Our vectors are row vectors and the matrices row-major.
     const int rows = layer_input_size;
     const int cols = layer_output_size;
 
-    net->weights[l] = nnMatrixMake(rows, cols);
-    net->biases[l]  = nnMatrixMake(1, cols);
+    net->weights[l]     = nnMatrixMake(rows, cols);
+    net->biases[l]      = nnMatrixMake(1, cols);
     net->activations[l] = activations[l];
   }
 
@@ -46,7 +47,7 @@ nnNeuralNetwork* nnMakeNet(int num_layers, const int* layer_sizes, const nnActiv
 }
 
 void nnDeleteNet(nnNeuralNetwork** net) {
-  if ( (!net) || (!(*net)) ) {
+  if ((!net) || (!(*net))) {
     return;
   }
   if ((*net)->weights != 0) {
@@ -77,7 +78,7 @@ void nnSetWeights(nnNeuralNetwork* net, const R* weights) {
 
   for (int l = 0; l < net->num_layers; ++l) {
     nnMatrix* layer_weights = &net->weights[l];
-    R* layer_values = layer_weights->values;
+    R*        layer_values  = layer_weights->values;
 
     for (int j = 0; j < layer_weights->rows * layer_weights->cols; ++j) {
       *layer_values++ = *weights++;
@@ -91,7 +92,7 @@ void nnSetBiases(nnNeuralNetwork* net, const R* biases) {
 
   for (int l = 0; l < net->num_layers; ++l) {
     nnMatrix* layer_biases = &net->biases[l];
-    R* layer_values = layer_biases->values;
+    R*        layer_values = layer_biases->values;
 
     for (int j = 0; j < layer_biases->rows * layer_biases->cols; ++j) {
       *layer_values++ = *biases++;
@@ -99,7 +100,8 @@ void nnSetBiases(nnNeuralNetwork* net, const R* biases) {
   }
 }
 
-void nnQuery(const nnNeuralNetwork* net, nnQueryObject* query, const nnMatrix* input) {
+void nnQuery(
+    const nnNeuralNetwork* net, nnQueryObject* query, const nnMatrix* input) {
   assert(net);
   assert(query);
   assert(input);
@@ -123,29 +125,34 @@ void nnQuery(const nnNeuralNetwork* net, nnQueryObject* query, const nnMatrix* i
       // We could also rewrite the original Mul function to go row x row,
       // decomposing the multiplication. Preserving the original meaning of Mul
       // makes everything clearer.
-      nnMatrix output_vector = nnMatrixBorrowRows(&query->layer_outputs[l], i, 1);
+      nnMatrix output_vector =
+          nnMatrixBorrowRows(&query->layer_outputs[l], i, 1);
       nnMatrixMul(&input_vector, layer_weights, &output_vector);
       nnMatrixAddRow(&output_vector, layer_biases, &output_vector);
 
       switch (net->activations[l]) {
-        case nnIdentity:
-          break;  // Nothing to do for the identity function.
-        case nnSigmoid:
-          sigmoid_array(output_vector.values, output_vector.values, output_vector.cols);
-          break;
-        case nnRelu:
-          relu_array(output_vector.values, output_vector.values, output_vector.cols);
-          break;
-        default:
-          assert(0);
+      case nnIdentity:
+        break; // Nothing to do for the identity function.
+      case nnSigmoid:
+        sigmoid_array(
+            output_vector.values, output_vector.values, output_vector.cols);
+        break;
+      case nnRelu:
+        relu_array(
+            output_vector.values, output_vector.values, output_vector.cols);
+        break;
+      default:
+        assert(0);
       }
 
-      input_vector = output_vector;  // Borrow.
+      input_vector = output_vector; // Borrow.
     }
   }
 }
 
-void nnQueryArray(const nnNeuralNetwork* net, nnQueryObject* query, const R* input, R* output) {
+void nnQueryArray(
+    const nnNeuralNetwork* net, nnQueryObject* query, const R* input,
+    R* output) {
   assert(net);
   assert(query);
   assert(input);
@@ -177,9 +184,9 @@ nnQueryObject* nnMakeQueryObject(const nnNeuralNetwork* net, int num_inputs) {
     return 0;
   }
   for (int l = 0; l < net->num_layers; ++l) {
-      const nnMatrix* layer_weights = &net->weights[l];
-      const int layer_output_size = nnLayerOutputSize(layer_weights);
-      query->layer_outputs[l] = nnMatrixMake(num_inputs, layer_output_size);
+    const nnMatrix* layer_weights     = &net->weights[l];
+    const int       layer_output_size = nnLayerOutputSize(layer_weights);
+    query->layer_outputs[l] = nnMatrixMake(num_inputs, layer_output_size);
   }
   query->network_outputs = &query->layer_outputs[net->num_layers - 1];
 
@@ -187,7 +194,7 @@ nnQueryObject* nnMakeQueryObject(const nnNeuralNetwork* net, int num_inputs) {
 }
 
 void nnDeleteQueryObject(nnQueryObject** query) {
-  if ( (!query) || (!(*query)) ) {
+  if ((!query) || (!(*query))) {
     return;
   }
   if ((*query)->layer_outputs != 0) {