anchor.diff:      printfn "testing count: %d" (countCorrectTesting net)
       printfn ""
   
  -    let train net samples = (net, samples) ||> List.fold (fun net (input, answers) -> (trainNet net input answers))
  +    let train net samples = (net, samples) ||> List.fold (fun net (input, answers) -> (backPropagate net input answers))
       let finalNet = 
           (net, [1..100000]) 
           ||> List.fold (fun net cycleNumber -> 
  
positive.code:         weightsOut = (mIdentity netOutputs.Length)
          outputLayerErrors = (answers, netOutputs) ||> List.map2 (-) }
     
      let newNeuronAndError inputs outputErrors outputWeights  output oldNeuron = 
          let neuronError = 
              ((outputWeights, outputErrors) ||> List.map2 (*)  |> List.sum) 
              * output * (1.0 - output) 
          let newNeuron = 
              (bias::inputs, oldNeuron) ||> List.map2 (fun input oldWeight -> 
                  oldWeight + learningConstant * neuronError * input)
          (newNeuron, neuronError)
      let newLayerAndErrors inputs  oldLayer bpData= 
          let newLayer, errors = 
              (bpData.weightsOut, bpData.values, oldLayer) 
              |||> List.map3 (newNeuronAndError inputs bpData.outputLayerErrors)
              |> List.unzip
          {   newNet = newLayer::(bpData.newNet)
              values = inputs 
              weightsOut = (mTranspose oldLayer).Tail
              outputLayerErrors = errors}
      let bpResult = (allInputs, net, initialBpState) |||> List.foldBack2 newLayerAndErrors  
      bpResult.newNet
  
  // Measure
  
negative.code:     let samples = getSamples xorCases 10000
      printfn "cost before: %f" (calcCost samples (feedForward net) )
      xorCases |> Array.iter (fun (inputs, answer) -> printfn "%f" (feedForward net inputs).[0])
      let finalNet = (net, samples) ||> List.fold (fun net (input, answers) -> (backPropagate net input answers))
      printfn "cost after:  %f" (calcCost samples (feedForward finalNet) )
      xorCases |> Array.iter (fun (inputs, answer) -> printfn "%f" (feedForward finalNet inputs).[0])
  
  