Compiler Explorer

Source code

const std = @import("std");
const assert = std.debug.assert;

pub fn Layer(comptime InputType: type, comptime input_size: usize, comptime layer_size_: usize) type {
    return struct {
        const SelfType = @This();

layer_size: usize = layer_size_,

weights: [layer_size_][input_size]InputType = undefined,
        biases: [input_size]InputType = undefined,

pub fn evaluate(self: *const SelfType, inputs: [*]InputType, outputs: [*]InputType) void {
            comptime var neuron_index: usize = 0;
            inline while (neuron_index < layer_size_) : (neuron_index += 1) {
                var input_index: usize = 0;
                var neuron_result: InputType = 0;
                while (input_index < input_size) : (input_index += 1) {
                    neuron_result += self.weights[neuron_index][input_index] * inputs[input_index] + self.biases[input_index];
                }
                outputs[neuron_index] = neuron_result;
            }
        }
    };
}

pub fn Network(comptime InputType: type, comptime layer_list: anytype) type {
    return struct {
        const SelfType = @This();

layers: @TypeOf(layer_list) = layer_list,

pub fn feedForward(self: *const SelfType, inputs: [*]InputType, outputs: [*]InputType) void {
            comptime assert(self.layers.len > 0);

var layer_inputs = inputs;
            comptime var layer_index: usize = 0;
            inline while (layer_index < self.layers.len - 1) : (layer_index += 1) {
                var output: [self.layers[layer_index].layer_size]InputType = undefined;
                self.layers[layer_index].evaluate(layer_inputs, &output);
                layer_inputs = &output;
            }
            self.layers[layer_index].evaluate(layer_inputs, outputs);
        }
    };
}

pub fn main() anyerror!void {
    var inputs = [2]i16{ 2, 3 };

assert(outputs[0] == 621);
}