Neural Networks DataSet learning

Question

for a while now, i I am writing my own neural network for recognizing digits. It works perfectly fine for one given input and one expected output. It's getting close to the values until the total error is arround around 0.00001 or something like that. But obviously i need my network to learn more then one pattern. I've written my own class DataSet which stores inputs and desired outputs. My question now is: How do i get my program to learn every single pattern from my set. For now i am doing it like this: just learning every pattern one by one and hoping that the total error is getting better. But in my net with (784 = 28*28) input neurons, 15 hidden neurons and 10 output neurons and only 3 patterns, why total error is arround 0.4 It doesnt match the target at all so i want to ask you what i can do.

My code below:

public void CalculateSignalErrors(Matrix1d in, Matrix1d exp) {

    int i, j, k, OutputLayer;
    double Sum;

    this.calculate(in, false);


    for (i = 0; i < this.OUTPUT_SIZE; i++) {
        signalErrors[this.NETWORK_SIZE - 1].set(i,
                (this.outputs[this.NETWORK_SIZE - 1].get(i) - exp.get(i))
                        * this.derivatives[this.NETWORK_SIZE - 1].get(i));

    }

    for(i = this.NETWORK_SIZE - 2; i > 0; i--){
        for(j = 0; j < outputs[i].X; j ++){
            Sum = 0;
            for(k = 0; k < outputs[i+1].X; k++){
                Sum = Sum + weights[i+1].get(k, j) * 
                        signalErrors[i+1].get(k);
            }
            signalErrors[i].set(j,derivatives[i].get(j) * Sum);
        }
    }

}

public void backpropagateError(double eta) {
    int i,j,k;
    for(i = this.NETWORK_SIZE-1; i > 0; i--){
        for(j = 0; j < outputs[i].X; j++){
            for(k = 0; k  < outputs[i-1].X; k++){
                this.weights[i].set(j, k,this.weights[i].get(j, k) + (-eta * this.signalErrors[i].get(j) * this.outputs[i-1].get(k)));
            }
            this.biases[i].set(j, this.biases[i].get(j) - eta * this.signalErrors[i].get(j));
        }
    }
}

public void train(Matrix1d in, Matrix1d exp, double eta){
    this.CalculateSignalErrors(in, exp);
    this.backpropagateError(eta);
}

and my training for datasets:

public void train(TrainSet set, double epochs, double eta, boolean printIt){

    for(int e = 0; e < epochs; e ++){
        TrainSetIterator it = set.iterator();
        while(it.hasNext()){
            Matrix1d[] v = it.next();
            this.train(v[0], v[1], eta);

        }
        if(printIt){
            //System.out.format("%-9s %-7s %-15s%n", "Epoch:", e , outputError(set));
            System.out.println(outputError(set));
        }
    }
}

My error calculations:

public double outputError(Matrix1d input, Matrix1d expected) {
    Matrix1d out = this.calculate(input, false);

    expected = expected.clone();
    out.sub(expected);


    return (out.length() * out.length() * 0.5);

}

public double outputError(TrainSet set){
    TrainSetIterator it = set.iterator();
    double e = 0;
    while(it.hasNext()){
        Matrix1d[] o = it.next();
        e += outputError(o[0], o[1]);
    }

    return (e / (double)(set.size()));
}

Also it's important to know that while i feed my data forward, i'm writing my derivatives directly into the neurons (incase you wonder what derivative[x].get(y) means. (x = layer) (y = neuron)