Java: микрооптимизация управления массивом

Я пытаюсь сделать порт Java простой нейронной сети прямого распространения.
Это, очевидно, включает много числовых вычислений, таким образом, я пытаюсь оптимизировать свой центральный цикл как можно больше. Результаты должны быть корректными в рамках float тип данных.

Мой текущий код смотрит следующим образом (обработка ошибок и удаленная инициализация):

/**
 * Simple implementation of a feedforward neural network. The network supports
 * including a bias neuron with a constant output of 1.0 and weighted synapses
 * to hidden and output layers.
 * 
 * @author Martin Wiboe
 */
public class FeedForwardNetwork {
private final int outputNeurons;    // No of neurons in output layer
private final int inputNeurons;     // No of neurons in input layer
private int largestLayerNeurons;    // No of neurons in largest layer
private final int numberLayers;     // No of layers
private final int[] neuronCounts;   // Neuron count in each layer, 0 is input
                                // layer.
private final float[][][] fWeights; // Weights between neurons.
                                    // fWeight[fromLayer][fromNeuron][toNeuron]
                                    // is the weight from fromNeuron in
                                    // fromLayer to toNeuron in layer
                                    // fromLayer+1.
private float[][] neuronOutput;     // Temporary storage of output from previous layer


public float[] compute(float[] input) {
    // Copy input values to input layer output
    for (int i = 0; i < inputNeurons; i++) {
        neuronOutput[0][i] = input[i];
    }

    // Loop through layers
    for (int layer = 1; layer < numberLayers; layer++) {

        // Loop over neurons in the layer and determine weighted input sum
        for (int neuron = 0; neuron < neuronCounts[layer]; neuron++) {
            // Bias neuron is the last neuron in the previous layer
            int biasNeuron = neuronCounts[layer - 1];

            // Get weighted input from bias neuron - output is always 1.0
            float activation = 1.0F * fWeights[layer - 1][biasNeuron][neuron];

            // Get weighted inputs from rest of neurons in previous layer
            for (int inputNeuron = 0; inputNeuron < biasNeuron; inputNeuron++) {
                activation += neuronOutput[layer-1][inputNeuron] * fWeights[layer - 1][inputNeuron][neuron];
            }

            // Store neuron output for next round of computation
            neuronOutput[layer][neuron] = sigmoid(activation);
        }
    }

    // Return output from network = output from last layer
    float[] result = new float[outputNeurons];
    for (int i = 0; i < outputNeurons; i++)
        result[i] = neuronOutput[numberLayers - 1][i];

    return result;
}

private final static float sigmoid(final float input) {
    return (float) (1.0F / (1.0F + Math.exp(-1.0F * input)));
}
}

Я выполняю JVM с - параметр сервера, и на данный момент мой код между 25% и на 50% медленнее, чем подобный код C. Что я могу сделать для улучшения этой ситуации?

Спасибо,

Martin Wiboe

Редактирование № 1: После наблюдения огромного количества ответов я должен, вероятно, разъяснить числа в нашем сценарии. Во время типичного выполнения методу позвонят по поводу приблизительно 50 000 раз с различными исходными данными. Типичная сеть имела бы numberLayers = 3 слоя с 190, 2 и 1 нейрон, соответственно. Самый внутренний цикл будет поэтому иметь о 2*191+3=385 повторения (при подсчете добавленного нейрона предвзятости в уровнях 0 и 1)

Редактирование № 1: После реализации различных предложений в этом потоке наша реализация практически с такой скоростью, как версия C (в ~2%). Спасибо за всю справку! Все предложения были полезны, но так как я могу только отметить один ответ как корректный, я дам его @Durandal и для предлагающий оптимизацию массива и для являющийся единственной предварительно вычислить for заголовок цикла.