C# EncogWriteHelper.WriteProperty方法代码示例

 public void Save(Stream os, object obj)
 {
     BasicNetwork network;
     FlatNetwork flat;
     IActivationFunction function;
     int num;
     IActivationFunction[] activationFunctions;
     int num2;
     EncogWriteHelper helper = new EncogWriteHelper(os);
     if ((((uint) num2) + ((uint) num)) >= 0)
     {
         goto Label_0290;
     }
     goto Label_0059;
     Label_0024:
     if (num < function.Params.Length)
     {
         helper.AddColumn(function.Params[num]);
         goto Label_0080;
     }
     if (-1 == 0)
     {
         goto Label_00CC;
     }
     helper.WriteLine();
     Label_0040:
     num2++;
     Label_0046:
     if (num2 < activationFunctions.Length)
     {
         goto Label_00F8;
     }
     helper.Flush();
     goto Label_0071;
     Label_0059:
     num++;
     if (((uint) num2) <= uint.MaxValue)
     {
         goto Label_0024;
     }
     Label_0071:
     if (1 != 0)
     {
         return;
     }
     goto Label_0290;
     Label_0080:
     if ((((uint) num2) + ((uint) num)) < 0)
     {
         goto Label_0135;
     }
     goto Label_0059;
     Label_00CC:
     helper.WriteProperty("biasActivation", flat.BiasActivation);
     helper.AddSubSection("ACTIVATION");
     activationFunctions = flat.ActivationFunctions;
     num2 = 0;
     goto Label_0046;
     Label_00F8:
     function = activationFunctions[num2];
     if (((uint) num2) >= 0)
     {
         helper.AddColumn(function.GetType().Name);
     }
     if (0x7fffffff != 0)
     {
         num = 0;
         goto Label_0024;
     }
     goto Label_0080;
     Label_0135:
     helper.WriteProperty("outputCount", flat.OutputCount);
     if ((((uint) num) & 0) != 0)
     {
         goto Label_00F8;
     }
     helper.WriteProperty("weightIndex", flat.WeightIndex);
     helper.WriteProperty("weights", flat.Weights);
     goto Label_00CC;
     Label_0290:
     network = (BasicNetwork) obj;
     flat = network.Structure.Flat;
     helper.AddSection("BASIC");
     helper.AddSubSection("PARAMS");
     helper.AddProperties(network.Properties);
     if (((uint) num2) < 0)
     {
         goto Label_0040;
     }
     helper.AddSubSection("NETWORK");
     helper.WriteProperty("beginTraining", flat.BeginTraining);
     helper.WriteProperty("connectionLimit", flat.ConnectionLimit);
     helper.WriteProperty("contextTargetOffset", flat.ContextTargetOffset);
     helper.WriteProperty("contextTargetSize", flat.ContextTargetSize);
     helper.WriteProperty("endTraining", flat.EndTraining);
     helper.WriteProperty("hasContext", flat.HasContext);
     helper.WriteProperty("inputCount", flat.InputCount);
     helper.WriteProperty("layerCounts", flat.LayerCounts);
     helper.WriteProperty("layerFeedCounts", flat.LayerFeedCounts);
     helper.WriteProperty("layerContextCount", flat.LayerContextCount);
//.........这里部分代码省略.........

 public void Save(Stream os, object obj)
 {
     CPNNetwork network;
     EncogWriteHelper helper = new EncogWriteHelper(os);
     if (0 == 0)
     {
         network = (CPNNetwork) obj;
         goto Label_00A8;
     }
     Label_000D:
     helper.WriteProperty("inputToInstar", network.WeightsInputToInstar);
     helper.WriteProperty("instarToInput", network.WeightsInstarToOutstar);
     helper.WriteProperty("winnerCount", network.WinnerCount);
     if (-1 != 0)
     {
         helper.Flush();
         return;
     }
     Label_0052:
     helper.AddProperties(network.Properties);
     if (0 == 0)
     {
         helper.AddSubSection("NETWORK");
         helper.WriteProperty("inputCount", network.InputCount);
         helper.WriteProperty("instar", network.InstarCount);
         helper.WriteProperty("outputCount", network.OutputCount);
         goto Label_00C5;
     }
     Label_00A8:
     helper.AddSection("CPN");
     helper.AddSubSection("PARAMS");
     if (15 != 0)
     {
         goto Label_0052;
     }
     Label_00C5:
     if (0 == 0)
     {
         goto Label_000D;
     }
 }

        /// <inheritdoc/>
        public void Save(Stream os, Object obj)
        {
            var xout = new EncogWriteHelper(os);
            var svm2 = (SupportVectorMachine) obj;
            xout.AddSection("SVM");
            xout.AddSubSection("PARAMS");
            xout.AddProperties(svm2.Properties);
            xout.AddSubSection("SVM-PARAM");
            xout.WriteProperty(PersistConst.InputCount, svm2.InputCount);
            xout.WriteProperty(ParamC, svm2.Params.C);
            xout.WriteProperty(ParamCacheSize,
                               svm2.Params.cache_size);
            xout.WriteProperty(ParamCoef0, svm2.Params.coef0);
            xout.WriteProperty(ParamDegree, svm2.Params.degree);
            xout.WriteProperty(ParamEps, svm2.Params.eps);
            xout.WriteProperty(ParamGamma, svm2.Params.gamma);
            xout.WriteProperty(ParamKernelType,
                               svm2.Params.kernel_type);
            xout.WriteProperty(ParamNumWeight,
                               svm2.Params.nr_weight);
            xout.WriteProperty(ParamNu, svm2.Params.nu);
            xout.WriteProperty(ParamP, svm2.Params.p);
            xout.WriteProperty(ParamProbability,
                               svm2.Params.probability);
            xout.WriteProperty(ParamShrinking,
                               svm2.Params.shrinking);
            /* xout.WriteProperty(PersistSVM.PARAM_START_ITERATIONS,
                    svm2.Params.statIterations); */
            xout.WriteProperty(ParamSVMType, svm2.Params.svm_type);
            xout.WriteProperty(ParamWeight, svm2.Params.weight);
            xout.WriteProperty(ParamWeightLabel,
                               svm2.Params.weight_label);
            if (svm2.Model != null)
            {
                xout.AddSubSection("SVM-MODEL");
                try
                {
                    var ba = new MemoryStream();
                    var w = new StreamWriter(ba);
                    svm.svm_save_model(w, svm2.Model);
                    var enc = new ASCIIEncoding();
                    xout.Write(enc.GetString(ba.ToArray()));
                    w.Close();
                    ba.Close();
                }
                catch (IOException ex)
                {
                    throw new PersistError(ex);
                }
            }

            xout.Flush();
        }

 public virtual void Save(Stream os, object obj)
 {
     EncogWriteHelper xout = new EncogWriteHelper(os);
     NEATNetwork network = (NEATNetwork) obj;
     xout.AddSection("NEAT");
     xout.AddSubSection("PARAMS");
     xout.AddProperties(network.Properties);
     xout.AddSubSection("NETWORK");
     if (8 != 0)
     {
     }
     xout.WriteProperty("inputCount", network.InputCount);
     xout.WriteProperty("outputCount", network.OutputCount);
     xout.WriteProperty("activationFunction", network.ActivationFunction);
     xout.WriteProperty("outAct", network.OutputActivationFunction);
     xout.WriteProperty("depth", network.NetworkDepth);
     Label_0087:
     xout.WriteProperty("snapshot", network.Snapshot);
     xout.AddSubSection("NEURONS");
     using (IEnumerator<NEATNeuron> enumerator = network.Neurons.GetEnumerator())
     {
         NEATNeuron current;
         goto Label_00E3;
     Label_00B2:
         if (8 == 0)
         {
             goto Label_00F6;
         }
         xout.AddColumn(current.ActivationResponse);
         xout.AddColumn(current.SplitX);
         xout.AddColumn(current.SplitY);
         xout.WriteLine();
     Label_00E3:
         if (!enumerator.MoveNext())
         {
             goto Label_0124;
         }
         current = enumerator.Current;
     Label_00F6:
         xout.AddColumn((int) current.NeuronID);
         xout.AddColumn(PersistNEATPopulation.NeuronTypeToString(current.NeuronType));
         goto Label_00B2;
     }
     Label_0124:
     xout.AddSubSection("LINKS");
     foreach (NEATNeuron neuron2 in network.Neurons)
     {
         foreach (NEATLink link in neuron2.OutputboundLinks)
         {
             WriteLink(xout, link);
         }
     }
     xout.Flush();
     if (-1 != 0)
     {
         return;
     }
     goto Label_0087;
 }

        /// <summary>
        /// Save a subsection.
        /// </summary>
        ///
        /// <param name="xout">The output file.</param>
        /// <param name="section">The section.</param>
        /// <param name="subSection">The subsection.</param>
        private void SaveSubSection(EncogWriteHelper xout,
                                    String section, String subSection)
        {
            if (!section.Equals(xout.CurrentSection))
            {
                xout.AddSection(section);
            }
            xout.AddSubSection(subSection);
            List<PropertyEntry> list = PropertyConstraints.Instance
                .GetEntries(section, subSection);
            list.Sort();

            foreach (PropertyEntry entry  in  list)
            {
                String key = section + ":" + subSection + "_"
                             + entry.Name;
                String v = _script.Properties.GetPropertyString(
                    key);
                xout.WriteProperty(entry.Name, v ?? "");
            }
        }

        /// <inheritdoc/>
        public void Save(Stream os, Object obj)
        {
            var output = new EncogWriteHelper(os);
            var pop = (NEATPopulation)obj;
            output.AddSection("NEAT-POPULATION");
            output.AddSubSection("CONFIG");
            output.WriteProperty(PersistConst.ActivationCycles, pop.ActivationCycles);

            if (pop.IsHyperNEAT)
            {
                output.WriteProperty(NEATPopulation.PropertyNEATActivation,TypeCppn);
            }
            else
            {
                IActivationFunction af = pop.ActivationFunctions.Contents[0].obj;
                output.WriteProperty(NEATPopulation.PropertyNEATActivation, af);
            }

            output.WriteProperty(PersistConst.InputCount, pop.InputCount);
            output.WriteProperty(PersistConst.OutputCount, pop.OutputCount);
            output.WriteProperty(NEATPopulation.PropertyCycles, pop.ActivationCycles);
            output.WriteProperty(NEATPopulation.PropertyPopulationSize, pop.PopulationSize);
            output.WriteProperty(NEATPopulation.PropertySurvivalRate, pop.SurvivalRate);
            output.AddSubSection("INNOVATIONS");
            if (pop.Innovations != null)
            {
                foreach (string key in pop.Innovations.Innovations.Keys)
                {
                    NEATInnovation innovation = pop.Innovations.Innovations[key];
                    output.AddColumn(key);
                    output.AddColumn(innovation.InnovationId);
                    output.AddColumn(innovation.NeuronId);
                    output.WriteLine();
                }
            }

            output.AddSubSection("SPECIES");

            // make sure the best species goes first
            ISpecies bestSpecies = pop.DetermineBestSpecies();
            if (bestSpecies != null)
            {
                SaveSpecies(output, bestSpecies);
            }

            // now write the other species, other than the best one
            foreach (ISpecies species in pop.Species)
            {
                if (species != bestSpecies)
                {
                    SaveSpecies(output, species);
                }
            }
            output.Flush();
        }

        /// <summary>
        /// 
        /// </summary>
        ///
        public void Save(Stream os, Object obj)
        {
            var xout = new EncogWriteHelper(os);
            var pnn = (BasicPNN) obj;
            xout.AddSection("PNN");
            xout.AddSubSection("PARAMS");
            xout.AddProperties(pnn.Properties);
            xout.AddSubSection("NETWORK");

            xout.WriteProperty(PersistConst.Error, pnn.Error);
            xout.WriteProperty(PersistConst.InputCount, pnn.InputCount);
            xout.WriteProperty(PersistConst.Kernel,
                               KernelToString(pnn.Kernel));
            xout.WriteProperty(PersistConst.OutputCount, pnn.OutputCount);
            xout.WriteProperty(PropertyOutputMode,
                               OutputModeToString(pnn.OutputMode));
            xout.WriteProperty(PersistConst.Sigma, pnn.Sigma);

            xout.AddSubSection("SAMPLES");

            if (pnn.Samples != null)
            {
                foreach (IMLDataPair pair in pnn.Samples)
                {
                    for (int i = 0; i < pair.Input.Count; i++)
                    {
                        xout.AddColumn(pair.Input[i]);
                    }

                    for (int i = 0; i < pair.Ideal.Count; i++)
                    {
                        xout.AddColumn(pair.Ideal[i]);
                    }
                    xout.WriteLine();
                }
            }
            xout.Flush();
        }

//.........这里部分代码省略.........
         helper.AddColumn(genome2.SpeciesID);
         goto Label_02FB;
     Label_0346:
         if (0 == 0)
         {
             goto Label_01F1;
         }
         if (0 != 0)
         {
             goto Label_02FB;
         }
         goto Label_030A;
     }
     Label_0361:
     helper.AddSubSection("SPECIES");
     goto Label_0018;
     Label_03B2:
     using (IEnumerator<IInnovation> enumerator = population.Innovations.Innovations.GetEnumerator())
     {
         IInnovation innovation;
         NEATInnovation innovation2;
         goto Label_03CC;
     Label_03C6:
         helper.WriteLine();
     Label_03CC:
         if (enumerator.MoveNext())
         {
             goto Label_0452;
         }
         goto Label_00DD;
     Label_03DA:
         helper.AddColumn(innovation2.SplitY);
         helper.AddColumn(innovation2.NeuronID);
         helper.AddColumn(innovation2.FromNeuronID);
         helper.AddColumn(innovation2.ToNeuronID);
         goto Label_03C6;
     Label_040C:
         if (0 != 0)
         {
             goto Label_03CC;
         }
         helper.AddColumn(innovation2.InnovationID);
         helper.AddColumn(InnovationTypeToString(innovation2.InnovationType));
         helper.AddColumn(NeuronTypeToString(innovation2.NeuronType));
         helper.AddColumn(innovation2.SplitX);
         goto Label_03DA;
     Label_0452:
         innovation = enumerator.Current;
         innovation2 = (NEATInnovation) innovation;
         if (3 != 0)
         {
             goto Label_040C;
         }
         goto Label_00DD;
     }
     if (0x7fffffff != 0)
     {
         goto Label_00D2;
     }
     goto Label_0018;
     if (-2147483648 != 0)
     {
         goto Label_000D;
     }
     Label_05B6:
     helper.AddSection("NEAT-POPULATION");
     helper.AddSubSection("CONFIG");
     helper.WriteProperty("snapshot", population.Snapshot);
     helper.WriteProperty("outAct", population.OutputActivationFunction);
     helper.WriteProperty("neatAct", population.NeatActivationFunction);
     if (0 != 0)
     {
         goto Label_00DD;
     }
     if (2 != 0)
     {
         helper.WriteProperty("inputCount", population.InputCount);
         helper.WriteProperty("outputCount", population.OutputCount);
         helper.WriteProperty("oldAgePenalty", population.OldAgePenalty);
     }
     helper.WriteProperty("oldAgeThreshold", population.OldAgeThreshold);
     helper.WriteProperty("populationSize", population.PopulationSize);
     helper.WriteProperty("survivalRate", population.SurvivalRate);
     if (0 != 0)
     {
         goto Label_0018;
     }
     helper.WriteProperty("youngAgeThreshold", population.YoungBonusAgeThreshold);
     helper.WriteProperty("youngAgeBonus", population.YoungScoreBonus);
     helper.WriteProperty("nextGenomeID", population.GenomeIDGenerate.CurrentID);
     helper.WriteProperty("nextInnovationID", population.InnovationIDGenerate.CurrentID);
     helper.WriteProperty("nextGeneID", population.GeneIDGenerate.CurrentID);
     helper.WriteProperty("nextSpeciesID", population.SpeciesIDGenerate.CurrentID);
     helper.AddSubSection("INNOVATIONS");
     if (0x7fffffff != 0)
     {
         goto Label_00D2;
     }
     goto Label_03B2;
 }

 public void Save(Stream os, object obj)
 {
     HopfieldNetwork network;
     EncogWriteHelper helper = new EncogWriteHelper(os);
     goto Label_00A2;
     Label_0028:
     helper.WriteProperty("neurons", network.NeuronCount);
     helper.Flush();
     if (4 != 0)
     {
         return;
     }
     if (4 != 0)
     {
         goto Label_00A2;
     }
     goto Label_0064;
     Label_004C:
     helper.WriteProperty("output", network.CurrentState.Data);
     goto Label_0028;
     Label_0064:
     helper.AddSection("HOPFIELD");
     helper.AddSubSection("PARAMS");
     if (2 == 0)
     {
         goto Label_004C;
     }
     helper.AddProperties(network.Properties);
     helper.AddSubSection("NETWORK");
     if (0 == 0)
     {
         helper.WriteProperty("weights", network.Weights);
         goto Label_004C;
     }
     goto Label_0028;
     Label_00A2:
     network = (HopfieldNetwork) obj;
     goto Label_0064;
 }

 public void Save(Stream os, object obj)
 {
     SupportVectorMachine machine;
     EncogWriteHelper helper = new EncogWriteHelper(os);
     if (8 != 0)
     {
     }
     Label_026A:
     machine = (SupportVectorMachine) obj;
     helper.AddSection("SVM");
     if (0 == 0)
     {
         while (true)
         {
             helper.AddSubSection("PARAMS");
             helper.AddProperties(machine.Properties);
             helper.AddSubSection("SVM-PARAM");
             helper.WriteProperty("inputCount", machine.InputCount);
             helper.WriteProperty("C", machine.Params.C);
             if (0 == 0)
             {
                 helper.WriteProperty("cacheSize", machine.Params.cache_size);
                 if (-2 == 0)
                 {
                     goto Label_026A;
                 }
                 helper.WriteProperty("coef0", machine.Params.coef0);
                 helper.WriteProperty("degree", machine.Params.degree);
                 helper.WriteProperty("eps", machine.Params.eps);
                 helper.WriteProperty("gamma", machine.Params.gamma);
                 helper.WriteProperty("kernelType", machine.Params.kernel_type);
             }
             helper.WriteProperty("nrWeight", machine.Params.nr_weight);
             if (1 != 0)
             {
                 helper.WriteProperty("nu", machine.Params.nu);
                 helper.WriteProperty("p", machine.Params.p);
                 helper.WriteProperty("probability", machine.Params.probability);
                 helper.WriteProperty("shrinking", machine.Params.shrinking);
                 helper.WriteProperty("svmType", machine.Params.svm_type);
                 helper.WriteProperty("weight", machine.Params.weight);
                 helper.WriteProperty("weightLabel", machine.Params.weight_label);
                 break;
             }
         }
     }
     Label_0092:
     while (machine.Model != null)
     {
         helper.AddSubSection("SVM-MODEL");
         try
         {
             StreamWriter writer;
             ASCIIEncoding encoding;
             MemoryStream stream = new MemoryStream();
             if (1 != 0)
             {
                 goto Label_005F;
             }
         Label_003E:
             helper.Write(encoding.GetString(stream.ToArray()));
             writer.Close();
             stream.Close();
             break;
         Label_005F:
             writer = new StreamWriter(stream);
             if (0 == 0)
             {
                 svm.svm_save_model(writer, machine.Model);
             }
             encoding = new ASCIIEncoding();
             goto Label_003E;
         }
         catch (IOException exception)
         {
             throw new PersistError(exception);
         }
     }
     while (true)
     {
         helper.Flush();
         if (-2147483648 != 0)
         {
             return;
         }
         if (0 != 0)
         {
             goto Label_0092;
         }
     }
 }

        /// <summary>
        /// 
        /// </summary>
        ///
        public void Save(Stream os, Object obj)
        {
            var xout = new EncogWriteHelper(os);
            var bam = (BAMNetwork) obj;
            xout.AddSection("BAM");
            xout.AddSubSection("PARAMS");
            xout.AddProperties(bam.Properties);
            xout.AddSubSection("NETWORK");

            xout.WriteProperty(PersistConst.PropertyF1Count, bam.F1Count);
            xout.WriteProperty(PersistConst.PropertyF2Count, bam.F2Count);
            xout.WriteProperty(PersistConst.PropertyWeightsF1F2,
                               bam.WeightsF1ToF2);
            xout.WriteProperty(PersistConst.PropertyWeightsF2F1,
                               bam.WeightsF2ToF1);

            xout.Flush();
        }

        /// <inheritdoc/>
        public void Save(Stream os, Object obj)
        {
            EncogWriteHelper writer = new EncogWriteHelper(os);
            HiddenMarkovModel net = (HiddenMarkovModel)obj;

            writer.AddSection("HMM");
            writer.AddSubSection("PARAMS");
            writer.AddProperties(net.Properties);
            writer.AddSubSection("CONFIG");

            writer.WriteProperty(HiddenMarkovModel.TAG_STATES, net.StateCount);
            if (net.Items != null)
            {
                writer.WriteProperty(HiddenMarkovModel.TAG_ITEMS, net.Items);
            }
            writer.WriteProperty(HiddenMarkovModel.TAG_PI, net.Pi);
            writer.WriteProperty(HiddenMarkovModel.TAG_TRANSITION, new Matrix(net.TransitionProbability));

            for (int i = 0; i < net.StateCount; i++)
            {
                writer.AddSubSection("DISTRIBUTION-" + i);
                IStateDistribution sd = net.StateDistributions[i];
                writer.WriteProperty(HiddenMarkovModel.TAG_DIST_TYPE, sd.GetType().Name);

                if (sd is ContinousDistribution)
                {
                    ContinousDistribution cDist = (ContinousDistribution)sd;
                    writer.WriteProperty(HiddenMarkovModel.TAG_MEAN, cDist.Mean);
                    writer.WriteProperty(HiddenMarkovModel.TAG_COVARIANCE, cDist.Covariance);

                }
                else if (sd is DiscreteDistribution)
                {
                    DiscreteDistribution dDist = (DiscreteDistribution)sd;
                    writer.WriteProperty(HiddenMarkovModel.TAG_PROBABILITIES, new Matrix(dDist.Probabilities));
                }
            }

            writer.Flush();
        }

 public void Save(Stream os, object obj)
 {
     EncogWriteHelper helper = new EncogWriteHelper(os);
     while (true)
     {
         SOMNetwork network = (SOMNetwork) obj;
         helper.AddSection("SOM");
         helper.AddSubSection("PARAMS");
         helper.AddProperties(network.Properties);
         helper.AddSubSection("NETWORK");
         helper.WriteProperty("weights", network.Weights);
         helper.WriteProperty("inputCount", network.InputCount);
         if (0 == 0)
         {
             helper.WriteProperty("outputCount", network.OutputCount);
             helper.Flush();
         }
         if ((0 != 0) || (0 == 0))
         {
             return;
         }
     }
 }

//.........这里部分代码省略.........
     }
     helper.AddSubSection("RBF");
     if ((((uint) num5) | 15) != 0)
     {
         goto Label_01B0;
     }
     goto Label_011D;
     Label_0117:
     num4++;
     Label_011D:
     if (num4 < @params.Length)
     {
         num = @params[num4];
         helper.AddColumn(num);
         goto Label_0117;
     }
     Label_0125:
     helper.WriteLine();
     num3++;
     goto Label_00FA;
     Label_0161:
     helper.AddColumn(function.GetType().Name);
     @params = function.Params;
     Label_017A:
     num4 = 0;
     if ((((uint) num5) + ((uint) index)) > uint.MaxValue)
     {
         goto Label_03BC;
     }
     if ((((uint) num4) + ((uint) num)) <= uint.MaxValue)
     {
         goto Label_011D;
     }
     Label_01B0:
     if (((uint) num3) >= 0)
     {
         goto Label_00C6;
     }
     Label_01C2:
     if (0xff == 0)
     {
         goto Label_017A;
     }
     num3 = 0;
     if ((((uint) index) | 1) != 0)
     {
         goto Label_00FA;
     }
     goto Label_00C6;
     Label_020D:
     helper.WriteProperty("biasActivation", flat.BiasActivation);
     helper.AddSubSection("ACTIVATION");
     activationFunctions = flat.ActivationFunctions;
     goto Label_01C2;
     Label_02A1:
     helper.WriteProperty("layerContextCount", flat.LayerContextCount);
     helper.WriteProperty("layerIndex", flat.LayerIndex);
     if ((((uint) index) + ((uint) num)) < 0)
     {
         goto Label_0117;
     }
     helper.WriteProperty("output", flat.LayerOutput);
     helper.WriteProperty("outputCount", flat.OutputCount);
     helper.WriteProperty("weightIndex", flat.WeightIndex);
     if ((((uint) num) - ((uint) num5)) < 0)
     {
         goto Label_03F8;
     }
     helper.WriteProperty("weights", flat.Weights);
     goto Label_020D;
     Label_02E5:
     helper.WriteProperty("inputCount", flat.InputCount);
     helper.WriteProperty("layerCounts", flat.LayerCounts);
     if ((((uint) num4) - ((uint) index)) < 0)
     {
         goto Label_0161;
     }
     helper.WriteProperty("layerFeedCounts", flat.LayerFeedCounts);
     if (0x7fffffff != 0)
     {
         goto Label_02A1;
     }
     Label_0378:
     helper.WriteProperty("beginTraining", flat.BeginTraining);
     helper.WriteProperty("connectionLimit", flat.ConnectionLimit);
     helper.WriteProperty("contextTargetOffset", flat.ContextTargetOffset);
     helper.WriteProperty("contextTargetSize", flat.ContextTargetSize);
     Label_03BC:
     helper.WriteProperty("endTraining", flat.EndTraining);
     helper.WriteProperty("hasContext", flat.HasContext);
     if ((((uint) num5) | 3) == 0)
     {
         goto Label_006E;
     }
     goto Label_02E5;
     Label_03F8:
     helper.AddProperties(network.Properties);
     helper.AddSubSection("NETWORK");
     goto Label_0378;
 }

 public void Save(Stream os, object obj)
 {
     EncogWriteHelper helper = new EncogWriteHelper(os);
     BAMNetwork network = (BAMNetwork) obj;
     helper.AddSection("BAM");
     if (0 == 0)
     {
         helper.AddSubSection("PARAMS");
         helper.AddProperties(network.Properties);
         if (0 == 0)
         {
             helper.AddSubSection("NETWORK");
             helper.WriteProperty("f1Count", network.F1Count);
             helper.WriteProperty("f2Count", network.F2Count);
             helper.WriteProperty("weightsF1F2", network.WeightsF1ToF2);
             helper.WriteProperty("weightsF2F1", network.WeightsF2ToF1);
             helper.Flush();
         }
     }
 }