/// <summary>Computations that depend on the observed value of vVector__111</summary>
        private void Changed_vVector__111()
        {
            if (this.Changed_vVector__111_iterationsDone == 1)
            {
                return;
            }
            this.vVector__111_marginal = new PointMass <Vector[]>(this.VVector__111);
            // The constant 'vVectorGaussian111'
            VectorGaussian vVectorGaussian111 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] {
                1547829870.0, 525077980.0, 200270.0
            }), new PositiveDefiniteMatrix(new double[3, 3] {
                { 4254590363351.0, 1127383488860.0, 433199230.0 }, { 1127383488860.0, 482723521821.0, 146764360.0 }, { 433199230.0, 146764360.0, 56221.0 }
            }));

            this.vVector333_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian111);
            // Buffer for ReplicateOp_Divide.Marginal<VectorGaussian>
            VectorGaussian vVector333_rep_B_toDef = default(VectorGaussian);

            // Message to 'vVector333_rep' from Replicate factor
            vVector333_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian111);
            // Message to 'vVector333_marginal' from Variable factor
            this.vVector333_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector333_rep_B_toDef, vVectorGaussian111, this.vVector333_marginal_F);
            DistributionStructArray <Gaussian, double> vdouble__333_F = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__333' Forwards messages.
            vdouble__333_F = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                vdouble__333_F[index111] = Gaussian.Uniform();
            }
            DistributionStructArray <Gaussian, double> vdouble__334_F = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__334' Forwards messages.
            vdouble__334_F = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                vdouble__334_F[index111] = Gaussian.Uniform();
            }
            DistributionRefArray <VectorGaussian, Vector> vVector333_rep_F = default(DistributionRefArray <VectorGaussian, Vector>);
            DistributionRefArray <VectorGaussian, Vector> vVector333_rep_B = default(DistributionRefArray <VectorGaussian, Vector>);

            // Create array for 'vVector333_rep' Forwards messages.
            vVector333_rep_F = new DistributionRefArray <VectorGaussian, Vector>(1);
            // Create array for 'vVector333_rep' Backwards messages.
            vVector333_rep_B = new DistributionRefArray <VectorGaussian, Vector>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                vVector333_rep_B[index111] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian111);
                vVector333_rep_F[index111] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian111);
            }
            // Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian>
            VectorGaussian vVector333_rep_F_marginal = default(VectorGaussian);

            // Message to 'vVector333_rep' from Replicate factor
            vVector333_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian111);
            // Message to 'vVector333_rep' from Replicate factor
            vVector333_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector333_rep_B_toDef, vVectorGaussian111, vVector333_rep_F_marginal);
            // Buffer for InnerProductOp.InnerProductAverageConditional
            // Create array for replicates of 'vVector333_rep_F_index111__AMean'
            Vector[] vVector333_rep_F_index111__AMean = new Vector[1];
            for (int index111 = 0; index111 < 1; index111++)
            {
                // Message to 'vdouble__334' from InnerProduct factor
                vVector333_rep_F_index111__AMean[index111] = InnerProductOp.AMeanInit(vVector333_rep_F[index111]);
            }
            // Buffer for InnerProductOp.AMean
            // Create array for replicates of 'vVector333_rep_F_index111__AVariance'
            PositiveDefiniteMatrix[] vVector333_rep_F_index111__AVariance = new PositiveDefiniteMatrix[1];
            for (int index111 = 0; index111 < 1; index111++)
            {
                // Message to 'vdouble__334' from InnerProduct factor
                vVector333_rep_F_index111__AVariance[index111] = InnerProductOp.AVarianceInit(vVector333_rep_F[index111]);
                // Message to 'vVector333_rep' from Replicate factor
                vVector333_rep_F[index111] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector333_rep_B[index111], vVector333_rep_F_marginal, index111, vVector333_rep_F[index111]);
            }
            // Create array for 'vdouble__334_marginal' Forwards messages.
            this.vdouble__334_marginal_F = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                this.vdouble__334_marginal_F[index111] = Gaussian.Uniform();
            }
            // Message from use of 'vdouble__334'
            DistributionStructArray <Gaussian, double> vdouble__334_use_B = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__334_use' Backwards messages.
            vdouble__334_use_B = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                vdouble__334_use_B[index111] = Gaussian.Uniform();
                // Message to 'vdouble__334' from InnerProduct factor
                vVector333_rep_F_index111__AVariance[index111] = InnerProductOp.AVariance(vVector333_rep_F[index111], vVector333_rep_F_index111__AVariance[index111]);
                // Message to 'vdouble__334' from InnerProduct factor
                vVector333_rep_F_index111__AMean[index111] = InnerProductOp.AMean(vVector333_rep_F[index111], vVector333_rep_F_index111__AVariance[index111], vVector333_rep_F_index111__AMean[index111]);
                // Message to 'vdouble__334' from InnerProduct factor
                vdouble__334_F[index111] = InnerProductOp.InnerProductAverageConditional(vVector333_rep_F_index111__AMean[index111], vVector333_rep_F_index111__AVariance[index111], this.VVector__111[index111]);
                // Message to 'vdouble__334_marginal' from DerivedVariable factor
                this.vdouble__334_marginal_F[index111] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__334_use_B[index111], vdouble__334_F[index111], this.vdouble__334_marginal_F[index111]);
            }
            // Create array for 'vdouble__333_marginal' Forwards messages.
            this.vdouble__333_marginal_F = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                this.vdouble__333_marginal_F[index111] = Gaussian.Uniform();
            }
            // Message from use of 'vdouble__333'
            DistributionStructArray <Gaussian, double> vdouble__333_use_B = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__333_use' Backwards messages.
            vdouble__333_use_B = new DistributionStructArray <Gaussian, double>(1);
            for (int index111 = 0; index111 < 1; index111++)
            {
                vdouble__333_use_B[index111] = Gaussian.Uniform();
                // Message to 'vdouble__333' from GaussianFromMeanAndVariance factor
                vdouble__333_F[index111] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__334_F[index111], 0.1);
                // Message to 'vdouble__333_marginal' from Variable factor
                this.vdouble__333_marginal_F[index111] = VariableOp.MarginalAverageConditional <Gaussian>(vdouble__333_use_B[index111], vdouble__333_F[index111], this.vdouble__333_marginal_F[index111]);
            }
            this.Changed_vVector__111_iterationsDone = 1;
        }
        /// <summary>Computations that depend on the observed value of vVector__66 and vdouble__198</summary>
        private void Changed_vVector__66_vdouble__198()
        {
            if (this.Changed_vVector__66_vdouble__198_iterationsDone == 1)
            {
                return;
            }
            this.vVector__66_marginal  = new PointMass <Vector[]>(this.VVector__66);
            this.vdouble__198_marginal = new DistributionStructArray <Gaussian, double>(5622, delegate(int index66) {
                return(Gaussian.Uniform());
            });
            this.vdouble__198_marginal = Distribution.SetPoint <DistributionStructArray <Gaussian, double>, double[]>(this.vdouble__198_marginal, this.Vdouble__198);
            // The constant 'vVectorGaussian66'
            VectorGaussian vVectorGaussian66 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] {
                0.0, 0.0, 0.0
            }), new PositiveDefiniteMatrix(new double[3, 3] {
                { 1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, 0.0, 1.0 }
            }));

            this.vVector199_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian66);
            // Message from use of 'vdouble__199'
            DistributionStructArray <Gaussian, double> vdouble__199_use_B = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__199_use' Backwards messages.
            vdouble__199_use_B = new DistributionStructArray <Gaussian, double>(5622);
            for (int index66 = 0; index66 < 5622; index66++)
            {
                vdouble__199_use_B[index66] = Gaussian.Uniform();
                // Message to 'vdouble__199_use' from GaussianFromMeanAndVariance factor
                vdouble__199_use_B[index66] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.Vdouble__198[index66], 0.1);
            }
            DistributionRefArray <VectorGaussian, Vector> vVector199_rep_B = default(DistributionRefArray <VectorGaussian, Vector>);

            // Create array for 'vVector199_rep' Backwards messages.
            vVector199_rep_B = new DistributionRefArray <VectorGaussian, Vector>(5622);
            for (int index66 = 0; index66 < 5622; index66++)
            {
                vVector199_rep_B[index66] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian66);
                // Message to 'vVector199_rep' from InnerProduct factor
                vVector199_rep_B[index66] = InnerProductOp.AAverageConditional(vdouble__199_use_B[index66], this.VVector__66[index66], vVector199_rep_B[index66]);
            }
            // Buffer for ReplicateOp_Divide.Marginal<VectorGaussian>
            VectorGaussian vVector199_rep_B_toDef = default(VectorGaussian);

            // Message to 'vVector199_rep' from Replicate factor
            vVector199_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian66);
            // Message to 'vVector199_rep' from Replicate factor
            vVector199_rep_B_toDef = ReplicateOp_Divide.ToDef <VectorGaussian>(vVector199_rep_B, vVector199_rep_B_toDef);
            // Message to 'vVector199_marginal' from Variable factor
            this.vVector199_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector199_rep_B_toDef, vVectorGaussian66, this.vVector199_marginal_F);
            DistributionStructArray <Gaussian, double> vdouble__199_F = default(DistributionStructArray <Gaussian, double>);

            // Create array for 'vdouble__199' Forwards messages.
            vdouble__199_F = new DistributionStructArray <Gaussian, double>(5622);
            for (int index66 = 0; index66 < 5622; index66++)
            {
                vdouble__199_F[index66] = Gaussian.Uniform();
            }
            DistributionRefArray <VectorGaussian, Vector> vVector199_rep_F = default(DistributionRefArray <VectorGaussian, Vector>);

            // Create array for 'vVector199_rep' Forwards messages.
            vVector199_rep_F = new DistributionRefArray <VectorGaussian, Vector>(5622);
            for (int index66 = 0; index66 < 5622; index66++)
            {
                vVector199_rep_F[index66] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian66);
            }
            // Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian>
            VectorGaussian vVector199_rep_F_marginal = default(VectorGaussian);

            // Message to 'vVector199_rep' from Replicate factor
            vVector199_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian66);
            // Message to 'vVector199_rep' from Replicate factor
            vVector199_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector199_rep_B_toDef, vVectorGaussian66, vVector199_rep_F_marginal);
            // Buffer for InnerProductOp.InnerProductAverageConditional
            // Create array for replicates of 'vVector199_rep_F_index66__AMean'
            Vector[] vVector199_rep_F_index66__AMean = new Vector[5622];
            for (int index66 = 0; index66 < 5622; index66++)
            {
                // Message to 'vdouble__199' from InnerProduct factor
                vVector199_rep_F_index66__AMean[index66] = InnerProductOp.AMeanInit(vVector199_rep_F[index66]);
            }
            // Buffer for InnerProductOp.AMean
            // Create array for replicates of 'vVector199_rep_F_index66__AVariance'
            PositiveDefiniteMatrix[] vVector199_rep_F_index66__AVariance = new PositiveDefiniteMatrix[5622];
            for (int index66 = 0; index66 < 5622; index66++)
            {
                // Message to 'vdouble__199' from InnerProduct factor
                vVector199_rep_F_index66__AVariance[index66] = InnerProductOp.AVarianceInit(vVector199_rep_F[index66]);
                // Message to 'vVector199_rep' from Replicate factor
                vVector199_rep_F[index66] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector199_rep_B[index66], vVector199_rep_F_marginal, index66, vVector199_rep_F[index66]);
            }
            // Create array for 'vdouble__199_marginal' Forwards messages.
            this.vdouble__199_marginal_F = new DistributionStructArray <Gaussian, double>(5622);
            for (int index66 = 0; index66 < 5622; index66++)
            {
                this.vdouble__199_marginal_F[index66] = Gaussian.Uniform();
                // Message to 'vdouble__199' from InnerProduct factor
                vVector199_rep_F_index66__AVariance[index66] = InnerProductOp.AVariance(vVector199_rep_F[index66], vVector199_rep_F_index66__AVariance[index66]);
                // Message to 'vdouble__199' from InnerProduct factor
                vVector199_rep_F_index66__AMean[index66] = InnerProductOp.AMean(vVector199_rep_F[index66], vVector199_rep_F_index66__AVariance[index66], vVector199_rep_F_index66__AMean[index66]);
                // Message to 'vdouble__199' from InnerProduct factor
                vdouble__199_F[index66] = InnerProductOp.InnerProductAverageConditional(vVector199_rep_F_index66__AMean[index66], vVector199_rep_F_index66__AVariance[index66], this.VVector__66[index66]);
                // Message to 'vdouble__199_marginal' from DerivedVariable factor
                this.vdouble__199_marginal_F[index66] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__199_use_B[index66], vdouble__199_F[index66], this.vdouble__199_marginal_F[index66]);
            }
            this.Changed_vVector__66_vdouble__198_iterationsDone = 1;
        }
Esempio n. 3
0
        /// <summary>Computations that depend on the observed value of numberOfIterations and vint__0 and vint__1</summary>
        /// <param name="numberOfIterations">The number of times to iterate each loop</param>
        private void Changed_numberOfIterations_vint__0_vint__1(int numberOfIterations)
        {
            if (this.Changed_numberOfIterations_vint__0_vint__1_isDone)
            {
                return;
            }
            DistributionStructArray <Gaussian, double> vdouble__0_F;
            Gaussian vdouble__0_F_reduced;

            // Create array for 'vdouble__0' Forwards messages.
            vdouble__0_F = new DistributionStructArray <Gaussian, double>(5);
            // Message to 'vdouble__0' from GaussianFromMeanAndVariance factor
            vdouble__0_F_reduced = GaussianFromMeanAndVarianceOp.SampleAverageConditional(6.0, 9.0);
            for (int index1 = 0; index1 < 5; index1++)
            {
                vdouble__0_F[index1] = vdouble__0_F_reduced;
                vdouble__0_F[index1] = vdouble__0_F_reduced;
            }
            // Create array for 'vdouble__0_marginal' Forwards messages.
            this.vdouble__0_marginal_F = new DistributionStructArray <Gaussian, double>(5);
            DistributionStructArray <Gaussian, double> vdouble__0_use_B;

            // Create array for 'vdouble__0_use' Backwards messages.
            vdouble__0_use_B = new DistributionStructArray <Gaussian, double>(5);
            for (int index1 = 0; index1 < 5; index1++)
            {
                vdouble__0_use_B[index1] = Gaussian.Uniform();
            }
            DistributionStructArray <Gaussian, double>[] vdouble__0_uses_F;
            // Create array for 'vdouble__0_uses' Forwards messages.
            vdouble__0_uses_F = new DistributionStructArray <Gaussian, double> [2];
            // Create array for 'vdouble__0_uses' Forwards messages.
            vdouble__0_uses_F[1] = new DistributionStructArray <Gaussian, double>(5);
            for (int index1 = 0; index1 < 5; index1++)
            {
                vdouble__0_uses_F[1][index1] = Gaussian.Uniform();
            }
            DistributionStructArray <Gaussian, double> vdouble__0_uses_F_1__marginal;

            // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor
            vdouble__0_uses_F_1__marginal = GetItemsOp <double> .MarginalInit <DistributionStructArray <Gaussian, double> >(vdouble__0_uses_F[1]);

            DistributionStructArray <Gaussian, double> vdouble__0_itemvint__1_index0__F;

            // Create array for 'vdouble__0_itemvint__1_index0_' Forwards messages.
            vdouble__0_itemvint__1_index0__F = new DistributionStructArray <Gaussian, double>(6);
            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble__0_itemvint__1_index0__F[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble11_F'
            DistributionStructArray <Gaussian, double> vdouble11_F = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble11_F[index0] = Gaussian.Uniform();
            }
            // Create array for 'vdouble__0_uses' Forwards messages.
            vdouble__0_uses_F[0] = new DistributionStructArray <Gaussian, double>(5);
            for (int index1 = 0; index1 < 5; index1++)
            {
                vdouble__0_uses_F[0][index1] = Gaussian.Uniform();
            }
            DistributionStructArray <Gaussian, double> vdouble__0_uses_F_0__marginal;

            // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor
            vdouble__0_uses_F_0__marginal = GetItemsOp <double> .MarginalInit <DistributionStructArray <Gaussian, double> >(vdouble__0_uses_F[0]);

            DistributionStructArray <Gaussian, double> vdouble__0_itemvint__0_index0__F;

            // Create array for 'vdouble__0_itemvint__0_index0_' Forwards messages.
            vdouble__0_itemvint__0_index0__F = new DistributionStructArray <Gaussian, double>(6);
            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble__0_itemvint__0_index0__F[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble8_F'
            DistributionStructArray <Gaussian, double> vdouble8_F = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble8_F[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble12_F'
            DistributionStructArray <Gaussian, double> vdouble12_F = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble12_F[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble12_B'
            DistributionStructArray <Gaussian, double> vdouble12_B = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble12_B[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble8_use_B'
            DistributionStructArray <Gaussian, double> vdouble8_use_B = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble8_use_B[index0] = Gaussian.Uniform();
            }
            // Create array for replicates of 'vdouble11_use_B'
            DistributionStructArray <Gaussian, double> vdouble11_use_B = new DistributionStructArray <Gaussian, double>(6);

            for (int index0 = 0; index0 < 6; index0++)
            {
                vdouble11_use_B[index0] = Gaussian.Uniform();
            }
            for (int iteration = this.numberOfIterationsDone; iteration < numberOfIterations; iteration++)
            {
                // Message to 'vdouble__0_uses' from Replicate factor
                vdouble__0_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_F, 1, vdouble__0_uses_F[1]);
                // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor
                vdouble__0_uses_F_1__marginal = GetItemsOp <double> .Marginal <DistributionStructArray <Gaussian, double>, Gaussian>(vdouble__0_uses_F[1], this.vdouble__0_uses_B[1], vdouble__0_uses_F_1__marginal);

                // Message to 'vdouble__0_uses' from Replicate factor
                vdouble__0_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_F, 0, vdouble__0_uses_F[0]);
                // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor
                vdouble__0_uses_F_0__marginal = GetItemsOp <double> .Marginal <DistributionStructArray <Gaussian, double>, Gaussian>(vdouble__0_uses_F[0], this.vdouble__0_uses_B[0], vdouble__0_uses_F_0__marginal);

                for (int index0 = 0; index0 < 6; index0++)
                {
                    // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor
                    vdouble__0_itemvint__1_index0__F[index0] = GetItemsOp <double> .ItemsAverageConditional <DistributionStructArray <Gaussian, double>, Gaussian>(this.vdouble__0_itemvint__1_index0__B[index0], vdouble__0_uses_F[1], vdouble__0_uses_F_1__marginal, this.Vint__1, index0, vdouble__0_itemvint__1_index0__F[index0]);

                    // Message to 'vdouble11' from GaussianFromMeanAndVariance factor
                    vdouble11_F[index0] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__0_itemvint__1_index0__F[index0], 1.0);
                    // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor
                    vdouble__0_itemvint__0_index0__F[index0] = GetItemsOp <double> .ItemsAverageConditional <DistributionStructArray <Gaussian, double>, Gaussian>(this.vdouble__0_itemvint__0_index0__B[index0], vdouble__0_uses_F[0], vdouble__0_uses_F_0__marginal, this.Vint__0, index0, vdouble__0_itemvint__0_index0__F[index0]);

                    // Message to 'vdouble8' from GaussianFromMeanAndVariance factor
                    vdouble8_F[index0] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__0_itemvint__0_index0__F[index0], 1.0);
                    // Message to 'vdouble12' from Difference factor
                    vdouble12_F[index0] = DoublePlusOp.AAverageConditional(vdouble8_F[index0], vdouble11_F[index0]);
                    // Message to 'vdouble12' from IsPositive factor
                    vdouble12_B[index0] = IsPositiveOp_Proper.XAverageConditional(Bernoulli.PointMass(true), vdouble12_F[index0]);
                    // Message to 'vdouble8_use' from Difference factor
                    vdouble8_use_B[index0] = DoublePlusOp.SumAverageConditional(vdouble12_B[index0], vdouble11_F[index0]);
                    // Message to 'vdouble__0_itemvint__0_index0_' from GaussianFromMeanAndVariance factor
                    this.vdouble__0_itemvint__0_index0__B[index0] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(vdouble8_use_B[index0], 1.0);
                    // Message to 'vdouble11_use' from Difference factor
                    vdouble11_use_B[index0] = DoublePlusOp.BAverageConditional(vdouble8_F[index0], vdouble12_B[index0]);
                    // Message to 'vdouble__0_itemvint__1_index0_' from GaussianFromMeanAndVariance factor
                    this.vdouble__0_itemvint__1_index0__B[index0] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(vdouble11_use_B[index0], 1.0);
                }
                // Message to 'vdouble__0_uses' from GetItems factor
                this.vdouble__0_uses_B[0] = GetItemsOp <double> .ArrayAverageConditional <Gaussian, DistributionStructArray <Gaussian, double> >(this.vdouble__0_itemvint__0_index0__B, this.Vint__0, this.vdouble__0_uses_B[0]);

                // Message to 'vdouble__0_uses' from GetItems factor
                this.vdouble__0_uses_B[1] = GetItemsOp <double> .ArrayAverageConditional <Gaussian, DistributionStructArray <Gaussian, double> >(this.vdouble__0_itemvint__1_index0__B, this.Vint__1, this.vdouble__0_uses_B[1]);

                this.OnProgressChanged(new ProgressChangedEventArgs(iteration));
            }
            // Message to 'vdouble__0_use' from Replicate factor
            vdouble__0_use_B = ReplicateOp_NoDivide.DefAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_use_B);
            for (int index1 = 0; index1 < 5; index1++)
            {
                this.vdouble__0_marginal_F[index1] = Gaussian.Uniform();
                // Message to 'vdouble__0_marginal' from Variable factor
                this.vdouble__0_marginal_F[index1] = VariableOp.MarginalAverageConditional <Gaussian>(vdouble__0_use_B[index1], vdouble__0_F_reduced, this.vdouble__0_marginal_F[index1]);
            }
            this.Changed_numberOfIterations_vint__0_vint__1_isDone = true;
        }
Esempio n. 4
0
 /// <summary>Computations that depend on the observed value of FeatureCount and FeatureValues and InstanceCount and Labels and numberOfIterations and WeightConstraints and WeightPriors</summary>
 /// <param name="numberOfIterations">The number of times to iterate each loop</param>
 private void Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8(int numberOfIterations)
 {
     if (this.Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8_isDone)
     {
         return;
     }
     for (int iteration = this.numberOfIterationsDone; iteration < numberOfIterations; iteration++)
     {
         for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
         {
             this.Weights_depth1_rep_F_marginal[FeatureRange] = ReplicateOp_Divide.Marginal <Gaussian>(this.Weights_depth1_rep_B_toDef[FeatureRange], this.Weights_uses_F[1][FeatureRange], this.Weights_depth1_rep_F_marginal[FeatureRange]);
         }
         for (int InstanceRange = 0; InstanceRange < this.instanceCount; InstanceRange++)
         {
             for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
             {
                 this.Weights_depth1_rep_F[FeatureRange][InstanceRange] = ReplicateOp_Divide.UsesAverageConditional <Gaussian>(this.Weights_depth1_rep_B[FeatureRange][InstanceRange], this.Weights_depth1_rep_F_marginal[FeatureRange], InstanceRange, this.Weights_depth1_rep_F[FeatureRange][InstanceRange]);
                 this.FeatureScores_F[InstanceRange][FeatureRange]      = GaussianProductOpBase.ProductAverageConditional(this.featureValues[InstanceRange][FeatureRange], this.Weights_depth1_rep_F[FeatureRange][InstanceRange]);
             }
             this.Score_F[InstanceRange]          = FastSumOp.SumAverageConditional(this.FeatureScores_F[InstanceRange]);
             this.NoisyScore_F[InstanceRange]     = GaussianFromMeanAndVarianceOp.SampleAverageConditional(this.Score_F[InstanceRange], 1.0);
             this.NoisyScore_use_B[InstanceRange] = IsPositiveOp_Proper.XAverageConditional(Bernoulli.PointMass(this.labels[InstanceRange]), this.NoisyScore_F[InstanceRange]);
             this.Score_B[InstanceRange]          = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.NoisyScore_use_B[InstanceRange], 1.0);
             this.FeatureScores_B[InstanceRange]  = FastSumOp.ArrayAverageConditional <DistributionStructArray <Gaussian, double> >(this.Score_B[InstanceRange], this.Score_F[InstanceRange], this.FeatureScores_F[InstanceRange], this.FeatureScores_B[InstanceRange]);
             for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
             {
                 this.Weights_depth1_rep_B[FeatureRange][InstanceRange] = GaussianProductOpBase.BAverageConditional(this.FeatureScores_B[InstanceRange][FeatureRange], this.featureValues[InstanceRange][FeatureRange]);
                 this.Weights_depth1_rep_F_marginal[FeatureRange]       = ReplicateOp_Divide.MarginalIncrement <Gaussian>(this.Weights_depth1_rep_F_marginal[FeatureRange], this.Weights_depth1_rep_F[FeatureRange][InstanceRange], this.Weights_depth1_rep_B[FeatureRange][InstanceRange]);
             }
         }
         for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
         {
             this.Weights_depth1_rep_B_toDef[FeatureRange] = ReplicateOp_Divide.ToDef <Gaussian>(this.Weights_depth1_rep_B[FeatureRange], this.Weights_depth1_rep_B_toDef[FeatureRange]);
         }
         this.OnProgressChanged(new ProgressChangedEventArgs(iteration));
     }
     for (int _iv = 0; _iv < this.featureCount; _iv++)
     {
         this.Weights_uses_B[1][_iv] = ArrayHelper.SetTo <Gaussian>(this.Weights_uses_B[1][_iv], this.Weights_depth1_rep_B_toDef[_iv]);
     }
     this.Weights_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.weightPriors, 0, this.Weights_uses_F[0]);
     this.ModelSelector_selector_cases_0_uses_B[6] = Bernoulli.FromLogOdds(ReplicateOp.LogEvidenceRatio <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.weightPriors, this.Weights_uses_F));
     this.ModelSelector_selector_cases_0_uses_B[7] = Bernoulli.FromLogOdds(ConstrainEqualRandomOp <double[]> .LogEvidenceRatio <DistributionStructArray <Gaussian, double> >(this.Weights_uses_F[0], this.weightConstraints));
     for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
     {
         this.ModelSelector_selector_cases_0_rep3_uses_B[FeatureRange][1] = Bernoulli.FromLogOdds(ReplicateOp.LogEvidenceRatio <Gaussian>(this.Weights_depth1_rep_B[FeatureRange], this.Weights_uses_F[1][FeatureRange], this.Weights_depth1_rep_F[FeatureRange]));
         this.ModelSelector_selector_cases_0_rep3_B[FeatureRange]         = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep3_uses_B[FeatureRange], this.ModelSelector_selector_cases_0_rep3_B[FeatureRange]);
     }
     this.ModelSelector_selector_cases_0_uses_B[12] = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep3_B, this.ModelSelector_selector_cases_0_uses_B[12]);
     for (int InstanceRange = 0; InstanceRange < this.instanceCount; InstanceRange++)
     {
         this.ModelSelector_selector_cases_0_rep8_B[InstanceRange] = Bernoulli.FromLogOdds(IsPositiveOp.LogEvidenceRatio(this.labels[InstanceRange], this.NoisyScore_F[InstanceRange]));
     }
     this.ModelSelector_selector_cases_0_uses_B[17] = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep8_B, this.ModelSelector_selector_cases_0_uses_B[17]);
     this.ModelSelector_selector_cases_0_B          = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_uses_B, this.ModelSelector_selector_cases_0_B);
     this.ModelSelector_selector_cases_B[0]         = ArrayHelper.SetTo <Bernoulli>(this.ModelSelector_selector_cases_B[0], this.ModelSelector_selector_cases_0_B);
     this.ModelSelector_selector_B = CasesOp.BAverageConditional(this.ModelSelector_selector_cases_B);
     this.ModelSelector_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(this.ModelSelector_selector_B, this.vBernoulli0, this.ModelSelector_marginal_F);
     this.Weights_use_B            = ReplicateOp_NoDivide.DefAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.Weights_use_B);
     this.Weights_marginal_F       = VariableOp.MarginalAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_use_B, this.weightPriors, this.Weights_marginal_F);
     this.Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8_isDone = true;
 }
        /// <summary>Computations that do not depend on observed values</summary>
        private void Constant()
        {
            if (this.Constant_isDone)
            {
                return;
            }
            Gaussian t1_F = default(Gaussian);

            this.t1_marginal_F = Gaussian.Uniform();
            Gaussian t1_use_B = Gaussian.Uniform();

            // Message to 't1' from GaussianFromMeanAndVariance factor
            t1_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(1.0, 1.0);
            Gaussian[] t1_uses_F;
            Gaussian[] t1_uses_B;
            // Create array for 't1_uses' Forwards messages.
            t1_uses_F = new Gaussian[2];
            // Create array for 't1_uses' Backwards messages.
            t1_uses_B    = new Gaussian[2];
            t1_uses_B[1] = Gaussian.Uniform();
            t1_uses_B[0] = Gaussian.Uniform();
            t1_uses_F[1] = Gaussian.Uniform();
            t1_uses_F[0] = Gaussian.Uniform();
            // Message to 't1_marginal' from Variable factor
            this.t1_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t1_use_B, t1_F, this.t1_marginal_F);
            // Message to 't1_uses' from Replicate factor
            t1_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t1_uses_B, t1_F, 0, t1_uses_F[0]);
            // Message to 't1_uses' from Replicate factor
            t1_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t1_uses_B, t1_F, 1, t1_uses_F[1]);
            Gaussian t2_F = default(Gaussian);

            this.t2_marginal_F = Gaussian.Uniform();
            Gaussian t2_use_B = Gaussian.Uniform();

            // Message to 't2' from GaussianFromMeanAndVariance factor
            t2_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(10.0, 1.0);
            Gaussian[] t2_uses_F;
            Gaussian[] t2_uses_B;
            // Create array for 't2_uses' Forwards messages.
            t2_uses_F = new Gaussian[2];
            // Create array for 't2_uses' Backwards messages.
            t2_uses_B    = new Gaussian[2];
            t2_uses_B[1] = Gaussian.Uniform();
            t2_uses_B[0] = Gaussian.Uniform();
            t2_uses_F[1] = Gaussian.Uniform();
            t2_uses_F[0] = Gaussian.Uniform();
            // Message to 't2_marginal' from Variable factor
            this.t2_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t2_use_B, t2_F, this.t2_marginal_F);
            // Message to 't2_uses' from Replicate factor
            t2_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t2_uses_B, t2_F, 0, t2_uses_F[0]);
            // Message to 't2_uses' from Replicate factor
            t2_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t2_uses_B, t2_F, 1, t2_uses_F[1]);
            Gaussian vdouble6_F = default(Gaussian);

            this.vdouble6_marginal_F = Gaussian.Uniform();
            Gaussian vdouble6_use_B = Gaussian.Uniform();

            // Message to 'vdouble6' from Plus factor
            vdouble6_F = DoublePlusOp.SumAverageConditional(t1_uses_F[0], t2_uses_F[0]);
            // Message to 'vdouble6_marginal' from DerivedVariable factor
            this.vdouble6_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble6_use_B, vdouble6_F, this.vdouble6_marginal_F);
            Gaussian t4_F = default(Gaussian);

            this.t4_marginal_F = Gaussian.Uniform();
            Gaussian t4_use_B = Gaussian.Uniform();

            // Message to 't4' from GaussianFromMeanAndVariance factor
            t4_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(2.0, 1.0);
            Gaussian[] t4_uses_F;
            Gaussian[] t4_uses_B;
            // Create array for 't4_uses' Forwards messages.
            t4_uses_F = new Gaussian[2];
            // Create array for 't4_uses' Backwards messages.
            t4_uses_B    = new Gaussian[2];
            t4_uses_B[1] = Gaussian.Uniform();
            t4_uses_B[0] = Gaussian.Uniform();
            t4_uses_F[1] = Gaussian.Uniform();
            t4_uses_F[0] = Gaussian.Uniform();
            // Message to 't4_marginal' from Variable factor
            this.t4_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t4_use_B, t4_F, this.t4_marginal_F);
            // Message to 't4_uses' from Replicate factor
            t4_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t4_uses_B, t4_F, 0, t4_uses_F[0]);
            // Message to 't4_uses' from Replicate factor
            t4_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t4_uses_B, t4_F, 1, t4_uses_F[1]);
            Gaussian vdouble10_F = default(Gaussian);

            this.vdouble10_marginal_F = Gaussian.Uniform();
            Gaussian vdouble10_use_B = Gaussian.Uniform();

            // Message to 'vdouble10' from Plus factor
            vdouble10_F = DoublePlusOp.SumAverageConditional(t1_uses_F[1], t2_uses_F[1]);
            // Message to 'vdouble10_marginal' from DerivedVariable factor
            this.vdouble10_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble10_use_B, vdouble10_F, this.vdouble10_marginal_F);
            Gaussian t5_F = default(Gaussian);

            this.t5_marginal_F = Gaussian.Uniform();
            Gaussian t5_use_B = Gaussian.Uniform();

            // Message to 't5' from Product factor
            t5_F = GaussianProductOp.ProductAverageConditional(t5_use_B, vdouble10_F, t4_uses_F[0]);
            // Message to 't5_marginal' from DerivedVariable factor
            this.t5_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(t5_use_B, t5_F, this.t5_marginal_F);
            Gaussian t7_F = default(Gaussian);

            this.t7_marginal_F = Gaussian.Uniform();
            Gaussian t7_use_B = Gaussian.Uniform();

            // Message to 't7' from Product factor
            t7_F = GaussianProductOp.ProductAverageConditional(t7_use_B, vdouble6_F, t4_uses_F[1]);
            // Message to 't7_marginal' from DerivedVariable factor
            this.t7_marginal_F   = DerivedVariableOp.MarginalAverageConditional <Gaussian>(t7_use_B, t7_F, this.t7_marginal_F);
            this.Constant_isDone = true;
        }