Ejemplo n.º 1
0
        }// end constructor

        internal override void Run()
        {
            YGen          genY   = YGen.EmptyInstance; // Pourra probablement prendre plusieurs formes.
            TrueValuesGen genTV  = null;
            GenObject     oSigma = EmptyGenObject.Instance;
            GenObject     oMu    = EmptyGenObject.Instance;
            GenObject     oME    = null;
            GenObject     oTV    = null;

            double[] burninMu;
            double[] burninSigma;
            double[] burninCV = null;
            double[] sampleMu;
            double[] sampleSigma;
            double[] sampleCV = null;
            double   mu;
            double   sigma;
            int      iter = -1, savedIter;
            double   muCondMean;
            double   muCondSD;

            try
            {
                //# Prepare dens.gen.icdf objects
                if (ME.Any)
                {
                    if (ME.ThroughCV)
                    {
                        if (OutcomeIsLogNormallyDistributed)
                        {
                            oTV = new TrueValue_CV_LogN_GenObject();
                        }
                        else
                        {
                            oTV = new TrueValue_CV_Norm_GenObject();
                        }
                    }
                    else
                    {
                        //oTV = new TrueValue_SD_GenObject();
                    }
                }

                if (ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                {
                    oMu    = new MuTruncatedData_GenObject(this.Data.N);            //# modif_0.12
                    oSigma = GenObject.GetSigmaTruncatedDataGenObject(this.Data.N); //# modif_0.12
                }
                else
                {
                    oSigma = EmptyGenObject.Instance;
                }

                if (ME.Any && !ME.Known)
                {
                    oME = GenObject.GetMeGenObject(this.ME, this.OutcomeIsLogNormallyDistributed, this.Data.N);
                }

                int nIterations = NBurnin + NIter * NThin;
                //les tableaux pour les chaines
                sampleMu    = Result.Chains.GetChain("muSample");
                sampleSigma = Result.Chains.GetChain("sdSample");
                burninMu    = Result.Chains.GetChain("muBurnin");
                burninSigma = Result.Chains.GetChain("sdBurnin");
                if (ME.ThroughCV)
                {
                    sampleCV = Result.Chains.GetChain("cvSample");
                    burninCV = Result.Chains.GetChain("cvBurnin");
                }

                //Initial values for mu and sigma
                mu    = this.InitMu;
                sigma = this.InitSD;

                //# Initialize measured values for subjects with censored values [modif_0.10]
                if (this.Data.AnyCensored)
                {
                    genY = YGen.Inits(data: this.Data, mu: mu, sigma: sigma, meThroughCV: true, logNormalDistrn: OutcomeIsLogNormallyDistributed);
                }

                if (ME.Any)
                {
                    ME.Parm = ME.InitialValue;
                }

                //# Start MCMC
                savedIter = 0; // pour les échantillons
                for (iter = 0; iter < nIterations; iter++)
                {
                    //# Sample true values (in presence of measurement error) [new_0.10]
                    if (ME.Any)
                    {
                        genTV = TrueValuesGen.GetInstance(genY, this.Data, mu, sigma, this.ME, OutcomeIsLogNormallyDistributed, o: oTV);
                    }

                    //# Sample y values for censored observations
                    if (this.Data.AnyCensored)
                    {
                        //y.gen(true.values, data, sigma, me, outcome.is.logNormally.distributed, mu=mu)
                        //On ne tient pas compte de true.values, ni de me ...
                        genY = YGen.GetInstance(this.ME, genTV, this.Data, mu, sigma, OutcomeIsLogNormallyDistributed);
                    }

                    //# Compute data points sum and square sum
                    OutLogoutMoments moments = OutLogoutMoments.Get(this.ME.Any, this.OutcomeIsLogNormallyDistributed, this.Data, genY, genTV);

                    //# Sample from f(sigma | mu)
                    //# modif_0.10
                    double sigmaBeta = (moments.Sum2 - 2 * mu * moments.Sum + this.Data.N * mu * mu) / 2.0;
                    if (sigmaBeta < 1e-6)
                    {
                        sigmaBeta = 0; // # protection against numeric imprecision
                    }

                    if (this.ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                    {
                        sigma = SigmaTruncatedDataGen.GetInstance(oSigma, SDRange, sigmaBeta, mu, sigma).Sigma;
                    }
                    else
                    {
                        sigma = WebExpoFunctions3.SqrtInvertedGammaGen(Data.N, sigmaBeta, this.SDRange, oSigma);
                    }

                    muCondMean = moments.Sum / this.Data.N;

                    if (this.ME.ThroughCV && !this.OutcomeIsLogNormallyDistributed)
                    {
                        mu = MuTruncatedGen.GetInstance(oMu, Tools.Combine(MuLower, MuUpper), muCondMean, sigma).Mu;
                    }
                    else
                    {
                        muCondSD = sigma / Math.Sqrt(this.Data.N);
                        mu       = RNorm4CensoredMeasures.RNormCensored(muCondMean, muCondSD, lower: this.MuLower, upper: this.MuUpper);
                    }

                    //# Sample Measurement Error from its posterior density
                    if (this.ME.Any && !ME.Known)
                    {
                        this.ME.Parm = MEParmGen.GetInstance(oME, this.ME, this.Data, genY, genTV).Parm;
                    }

                    if (iter < NBurnin)
                    {
                        if (MonitorBurnin)
                        {
                            burninMu[iter]    = mu;
                            burninSigma[iter] = sigma;
                            if (this.ME.Any && !this.ME.Known)
                            {
                                burninCV[iter] = ME.Parm;
                            }
                        }
                    }
                    else if ((iter - NBurnin) % NThin == 0)
                    {
                        sampleMu[savedIter]    = mu;
                        sampleSigma[savedIter] = sigma;
                        if (this.ME.Any && !this.ME.Known)
                        {
                            sampleCV[savedIter] = ME.Parm;
                        }

                        savedIter++;
                    }
                }// for( int iter = 1 ...
            } catch (Exception ex)
            {
                this.Result.Messages.AddError(WEException.GetStandardMessage(ex, iter, Result.PRNGSeed), this.ClassName);
                return;
            }
        }//compute
Ejemplo n.º 2
0
        }// end constructor

        /*
         * La méthode étant internal, elle peut être invoquée d'un programme externe à la librairie.
         * La seule méthode qui peut invoquer Run, c'est la méthode Compute de Model qui ne le fera que si le modèle est
         * jugé valide.
         */
        internal override void Run()
        {
            SGNFnAParam   localA = null;
            GenObject     oTV    = null;
            GenObject     oMu    = null;
            GenObject     oSigma = null;
            GenObject     oME    = null;
            YGen          genY   = YGen.EmptyInstance;
            TrueValuesGen genTV  = null;

            double[] burninMu;
            double[] burninSigma;
            double[] burninCV = null;
            double[] sampleMu;
            double[] sampleSigma;
            double[] sampleCV = null;
            double   mu;
            double   sigma;
            int      iter = -1, savedIter;
            double   muCondMean;
            double   yBar;
            double   muCondSD;

            double[] pLim = new double[2];
            double   p;

            double[] muLim = new double[] { this.MuLower, this.MuUpper };
            double   logSigmaSD;

            try
            {
                logSigmaSD = 1 / Math.Sqrt(this.LogSigmaPrec);
                if (ME.Any)
                {
                    if (ME.ThroughCV)
                    {
                        if (OutcomeIsLogNormallyDistributed)
                        {
                            oTV = new TrueValue_CV_LogN_GenObject();
                        }
                        else
                        {
                            oTV = new TrueValue_CV_Norm_GenObject();
                        }
                    }
                    else
                    {
                        //oTV = new TrueValue_SD_GenObject();
                    }
                }

                //# modif_0.12
                int combinedN = this.Data.N + (this.PastData.Defined ? PastData.N : 0);
                if (ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                {
                    oMu    = new MuTruncatedData_GenObject(combinedN);                                              //# modif_0.12
                    oSigma = GenObject.GetSigmaTruncatedDataLNormGenObject(combinedN, this.LogSigmaMu, logSigmaSD); //# modif_0.12
                }
                else
                {
                    oSigma = GenObject.GetSigmaGenObject(combinedN, this.LogSigmaMu, logSigmaSD); //# modif_0.12
                }

                localA = oSigma.A.Clone();
                if (ME.Any && !ME.Known)
                {
                    oME = GenObject.GetMeGenObject(this.ME, this.OutcomeIsLogNormallyDistributed, this.Data.N);
                }

                int nIterations = NBurnin + NIter * NThin;
                //les tableaux pour les chaines
                sampleMu    = Result.Chains.GetChain("muSample");
                sampleSigma = Result.Chains.GetChain("sdSample");
                burninMu    = Result.Chains.GetChain("muBurnin");
                burninSigma = Result.Chains.GetChain("sdBurnin");
                if (ME.ThroughCV)
                {
                    sampleCV = Result.Chains.GetChain("cvSample");
                    burninCV = Result.Chains.GetChain("cvBurnin");
                }

                bool inestimableLowerLimit = false;

                //Initial values for mu and sigma
                mu        = InitMu;
                sigma     = InitSigma;
                savedIter = 0; // pour les échantillons
                if (this.Data.AnyCensored)
                {
                    genY = YGen.Inits(this.Data, mu, sigma, meThroughCV: this.ME.ThroughCV, logNormalDistrn: OutcomeIsLogNormallyDistributed);
                }

                if (ME.Any)
                {
                    ME.Parm = ME.InitialValue;
                }


                //Boucle principale
                for (iter = 0; iter < nIterations; iter++)
                {
                    if (ME.Any)
                    {
                        genTV = TrueValuesGen.GetInstance(genY, this.Data, mu, sigma, this.ME, logNormalDistrn: OutcomeIsLogNormallyDistributed, o: oTV);
                    }

                    if (this.Data.AnyCensored)
                    {
                        //y.gen(true.values, data, sigma, me, outcome.is.logNormally.distributed, mu=mu)
                        //On ne tient pas compte de true.values, ni de me ...
                        genY = YGen.GetInstance(this.ME, genTV, this.Data, mu, sigma, OutcomeIsLogNormallyDistributed);
                    }

                    OutLogoutMoments moments   = OutLogoutMoments.Get(this.ME.Any, this.OutcomeIsLogNormallyDistributed, this.Data, genY, genTV);
                    double           sigmaBeta = (moments.Sum2 - 2 * mu * moments.Sum + this.Data.N * mu * mu) / 2.0;
                    if (PastData.Defined)
                    {
                        sigmaBeta = sigmaBeta + PastData.N / 2.0 * Math.Pow(PastData.Mean - mu, 2) + PastData.NS2 / 2.0;
                    }

                    double[] start = new double[0];
                    if (this.ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                    {
                        //ici
                        //        A <- c(o.sigma$A, list(b=sigma.beta, mu=mu))
                        localA                = oSigma.A.Clone();
                        localA.B              = sigmaBeta;
                        localA.Mu             = mu;
                        start                 = Tools.Combine(sigma);
                        inestimableLowerLimit = false;
                    }
                    else
                    {
                        localA.B = sigmaBeta;
                        start    = oSigma.Start(localA);
                        inestimableLowerLimit = true;
                    }

                    Icdf icdf = new Icdf(oSigma, localA, Tools.Combine(0, double.PositiveInfinity));
                    sigma      = icdf.Bidon(start, inestimableLowerLimit);
                    yBar       = moments.Sum / this.Data.N;
                    muCondMean = this.PastData.Defined ? (moments.Sum + PastData.N * PastData.Mean) / combinedN : yBar; // # new_0.12
                    if (this.ME.ThroughCV && !this.OutcomeIsLogNormallyDistributed)
                    {
                        mu = MuTruncatedGen.GetInstance(oMu, muLim, muCondMean, sigma).Mu;
                    }
                    else
                    {
                        muCondSD = sigma / Math.Sqrt(combinedN);
                        pLim     = NormalDistribution.PNorm(muLim.Substract(muCondMean).Divide(muCondSD));
                        p        = UniformDistribution.RUnif(1, pLim[0], pLim[1])[0];
                        mu       = NormalDistribution.QNorm(p, mu: muCondMean, sigma: muCondSD);
                    }

                    //# Sample Measurement Error from its posterior density
                    if (this.ME.Any && !this.ME.Known)
                    {
                        this.ME.Parm = MEParmGen.GetInstance(oME, this.ME, this.Data, genY, genTV).Parm;
                    }

                    if (iter < NBurnin)
                    {
                        if (MonitorBurnin)
                        {
                            burninMu[iter]    = mu;
                            burninSigma[iter] = sigma;
                            if (this.ME.Any && !this.ME.Known)
                            {
                                burninCV[iter] = ME.Parm;
                            }
                        }
                    }
                    else if ((iter - NBurnin) % NThin == 0)
                    {
                        sampleMu[savedIter]    = mu;
                        sampleSigma[savedIter] = sigma;
                        if (this.ME.Any && !this.ME.Known)
                        {
                            sampleCV[savedIter] = ME.Parm;
                        }

                        savedIter++;
                    }
                }// for( int iter = 1 ...
            }
            catch (Exception ex)
            {
                this.Result.Messages.AddError(WEException.GetStandardMessage(ex, iter, Result.PRNGSeed), this.ClassName);
                return;
            }
        } //end Run
Ejemplo n.º 3
0
        internal override void Run()
        {
            ChainNamePair b_s;

            b_s = Mcmc.GetChainNames("muOverall");
            double[] muOverallBurnin = Result.Chains.GetChain(b_s.Burnin);
            double[] muOverallSample = Result.Chains.GetChain(b_s.Sample);
            b_s = Mcmc.GetChainNames("sigmaWithin");
            double[] sigmaWithinBurnin = Result.Chains.GetChain(b_s.Burnin);
            double[] sigmaWithinSample = Result.Chains.GetChain(b_s.Sample);
            b_s = Mcmc.GetChainNames("sigmaBetween");
            double[] sigmaBetweenBurnin = Result.Chains.GetChain(b_s.Burnin);
            double[] sigmaBetweenSample = Result.Chains.GetChain(b_s.Sample);

            double[][] workerBurnin = new double[Data.NWorkers][];
            double[][] workerSample = new double[Data.NWorkers][];

            int iTag = 0;

            foreach (string tag in Data.WorkersByTag.Keys)
            {
                b_s = Mcmc.GetWorkerChainNames(tag);
                workerBurnin[iTag] = Result.Chains.GetChain(b_s.Burnin);
                workerSample[iTag] = Result.Chains.GetChain(b_s.Sample);
                iTag++;
            }

            int iter = -1, savedIter = 0;

            try
            {
                double logSigmaWithinSD  = 1 / Math.Sqrt(LogSigmaWithinPrec);
                double logSigmaBetweenSD = 1 / Math.Sqrt(LogSigmaBetweenPrec);

                //# Prepare dens.gen.icdf objects
                if (this.ME.Any)
                {
                    //o.tv < -truevalue.gen.object(me, outcome.is.logNormally.distributed)
                }

                if (this.ME.ThroughCV && !this.OutcomeIsLogNormallyDistributed)
                {
                    //o.mu.overall < -mu.truncatedData.gen.local.object(data$N, data$worker$count)
                    //o.mu.worker < -mu.worker.truncatedData.gen.object(data$worker$count)
                }

                GenObject oSB = null, oSW = null;
                if (this.UseUniformPriorOnSds)
                {
                    if (Data.NWorkers <= 1)
                    {
                        oSB = new Sigma_woLM_GenObject(Data.NWorkers);
                    }
                    else
                    {
                        oSB = null;
                    }
                }
                else
                {
                    oSB = new Sigma_LM_GenObject(Data.NWorkers, this.LogSigmaBetweenMu, logSigmaBetweenSD);
                }

                if (this.ME.ThroughCV && !this.OutcomeIsLogNormallyDistributed)
                {
                    //if (use.uniform.prior.on.sds)
                    //{
                    //    o.sw < -sigma.within.truncatedData.gen.object(data$N, data$worker$count, T, range = sigma.within.range)
                    //}
                    //else
                    //{
                    //    o.sw < -sigma.within.truncatedData.gen.object(data$N, data$worker$count, F, lnorm.mu = log.sigma.within.mu, lnorm.sd = log.sigma.within.sd)
                    //}
                }
                else
                {
                    if (this.UseUniformPriorOnSds)
                    {
                        if (Data.N <= 1)
                        {
                            oSW = new Sigma_woLM_GenObject(Data.N);
                        }
                        else
                        {
                            oSW = null;
                        }
                    }
                    else
                    {
                        oSW = new Sigma_LM_GenObject(this.Data.N, lNormMu: this.LogSigmaWithinMu, lNormSd: logSigmaWithinSD);
                    }
                }

                if (this.ME.Any && !this.ME.Known)
                {
                    //o.me < -me.gen.object(me, outcome.is.logNormally.distributed, data$N)
                }

                double muOverall   = this.InitMuOverall;
                double sigmaWithin = InitSigmaWithin;

                //# Initialize measured values for subjects with censored values [new_0.10]
                YGen       genY       = YGen.GetEmptyObject();
                WorkerData workerData = new WorkerData(this);

                this.ResultParams    = new Object[1];
                this.ResultParams[0] = this.Data.WorkersByTag.Keys;

                if (this.Data.AnyCensored)
                {
                    genY = YGen.Inits(data: this.Data, mu: muOverall, sigma: sigmaWithin, meThroughCV: false, logNormalDistrn: OutcomeIsLogNormallyDistributed);
                    workerData.UpdateGeneratedValues(genY);
                }


                double[] muWorker = workerData.MuWorker;
                workerData.AdjustMuOverall(this.MuOverallLower, this.MuOverallUpper);
                muOverall = workerData.MuOverall;
                muWorker  = muWorker.Substract(muOverall); // # center mu.worker

                double[] predicted = workerData.GetPredictedMeans(muOverall);
                sigmaWithin = workerData.GetSigmaWithin();


                int nIterations = NBurnin + NIter * NThin;

                for (iter = 0; iter < nIterations; iter++)
                {
                    if (this.ME.Any)
                    {
                        //true.values < -truevalues.gen.local(gen.y, data, me, mu.worker, o = o.tv)
                    }

                    //# Sample y values for censored observations
                    if (this.Data.AnyCensored)
                    {
                        //function(true.values, data, me, mu.worker, mu=mu.overall, sigma=sigma.within, logNormal.distrn=outcome.is.logNormally.distributed)
                        genY = workerData.GenYLocal(muWorker, muOverall, sigmaWithin);
                        workerData.UpdateGeneratedValues(genY);
                    }

                    double[] yWorkerAvg = workerData.MuWorker;
                    double   yAvg       = workerData.Average;

                    //# Sample from f(sigma.within | other parms)
                    double[]    residuals = workerData.GetGenValues().Substract(muWorker.Extract(workerData.WorkerIds)).Substract(muOverall);
                    double      b         = residuals.Sqr().ToArray().Sum() / 2.0;
                    SGNFnAParam localA    = null;

                    if (this.ME.ThroughCV && !this.OutcomeIsLogNormallyDistributed)
                    {
                        //A < -c(o.sw$A, list(b = b, mu = mu.overall, muk = mu.worker))
                        //sigma.within < -dens.gen.icdf(o.sw, A, range = o.sw$range, start = sigma.within, inestimable.lower.limit = o.sw$inestimable.lower.limit)
                    }
                    else
                    {
                        if (this.UseUniformPriorOnSds)
                        {
                            sigmaWithin = WebExpoFunctions3.SqrtInvertedGammaGen(Data.N, b, SigmaWithinRange.Copy(), oSW);
                        }
                        else
                        {
                            localA     = oSW.A.Clone();
                            localA.B   = b;
                            localA.Mu  = muOverall;
                            localA.Muk = muWorker;
                            Icdf icdf = new Icdf(oSW, localA, range: Tools.Combine(0, double.PositiveInfinity));
                            sigmaWithin = icdf.Bidon(start: oSW.Start(localA), inestLowerLim: true);
                        }
                    }

                    //# Sample from f(sigma.between | other parms)
                    b = muWorker.Sqr().Sum() / 2.0;

                    double sigmaBetween = 0;
                    if (UseUniformPriorOnSds)
                    {
                        sigmaBetween = WebExpoFunctions3.SqrtInvertedGammaGen(Data.NWorkers, b, this.SigmaBetweenRange.Copy(), oSB);
                    }
                    else
                    {
                        localA   = oSB.A.Clone();
                        localA.B = b;
                        Icdf icdf = new Icdf(oSB, localA, range: Tools.Combine(0, double.PositiveInfinity));
                        sigmaBetween = icdf.Bidon(start: oSB.Start(localA), inestLowerLim: true);
                    }

                    //# Sample from f(mu.overall | other parms)
                    //# modif_0.10
                    double tmpMean = yAvg - (muWorker.Multiply(this.Data.WorkerCounts).Sum() / this.Data.N);


                    if (this.ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                    {
                        //muOverall = mu.truncatedData.gen.local(o.mu.overall, tmp.mean, sigma.within, mu.worker, mu.overall.range, current.value = mu.overall)
                    }
                    else
                    {
                        double tmpSD = sigmaWithin / Math.Sqrt(this.Data.N);
                        muOverall = RNorm4CensoredMeasures.RNormCensored(tmpMean, tmpSD, lower: this.MuOverallLower, upper: this.MuOverallUpper);
                    }

                    //# Sample from f(mu.worker's | other parms)
                    //# modif_0.10

                    double[] sigma2A = Tools.Rep(Math.Pow(sigmaWithin, 2.0), this.Data.NWorkers).Divide(this.Data.WorkerCounts); // # vector of length '# of workers'
                    double   sigma2B = Math.Pow(sigmaBetween, 2);                                                                // # scalar
                    double[] muA     = yWorkerAvg.Substract(muOverall);                                                          // # vector of length '# of workers'
                    double[] mukStar = muA.Multiply(sigma2B).Divide(sigma2A.Add(sigma2B));                                       // # vector of length '# of workers'
                    double[] s2kStar = sigma2A.Multiply(sigma2B).Divide(sigma2A.Add(sigma2B));                                   // # vector of length '# of workers'

                    if (this.ME.ThroughCV && !OutcomeIsLogNormallyDistributed)
                    {
                        //muWorker = mu.worker.truncatedData.gen(o.mu.worker, muk.star, s2k.star, mu.overall, sigma.within, mu.worker)
                    }
                    else
                    {
                        muWorker = NormalDistribution.RNorm(this.Data.NWorkers, mu: mukStar, sigma: s2kStar.Sqrt());
                    }

                    if (iter < NBurnin)
                    {
                        if (MonitorBurnin)
                        {
                            muOverallBurnin[iter]    = muOverall;
                            sigmaBetweenBurnin[iter] = sigmaBetween;
                            sigmaWithinBurnin[iter]  = sigmaWithin;
                            SaveWorkerChainData(iter, muWorker, workerBurnin);
                        }
                    }
                    else if ((iter - NBurnin) % NThin == 0)
                    {
                        muOverallSample[savedIter]    = muOverall;
                        sigmaBetweenSample[savedIter] = sigmaBetween;
                        sigmaWithinSample[savedIter]  = sigmaWithin;
                        SaveWorkerChainData(savedIter, muWorker, workerSample);
                        savedIter++;
                    }
                } //for ...
            }
            catch (Exception ex)
            {
                this.Result.Messages.AddError(WEException.GetStandardMessage(ex, iter, Result.PRNGSeed), this.ClassName);
                return;
            }
        }