internal override double LogFSecond(double mu, SGNFnAParam A) { double z = mu / A.S; LPhiObject lphio = WebExpoFunctions3.LPhi(z); return(A.N / A.S2 * (z * lphio.R[0] + lphio.R2[0] - 1)); }
public SEGUninformativeModel(MeasureList measures, UninformativeModelParameters specificParams, McmcParameters mcmcParams = null) : base(measures, specificParams.LogNormalDstrn, /*new Range(specificParams.MuLower, specificParams.MuUpper, specificParams.InitMu),*/ mcmcParams) { this.MuLower = specificParams.MuLower; this.MuUpper = specificParams.MuUpper; this.SDRange = specificParams.SDRange; this.InitMu = specificParams.InitMu; this.InitSD = specificParams.InitSD; this.Result = new ModelResult(this, "mu", "sd"); bool testSD = double.IsNaN(this.InitSD) || (this.InitSD == 0); if (Tools.IsND(this.InitMu) || testSD) { InitialValues initVals = WebExpoFunctions3.DefaultInits(this.Data, this.OutcomeIsLogNormallyDistributed, Tools.Combine(this.MuLower, this.MuUpper), this.SDRange, includeCensoredData: false); if (Tools.IsND(this.InitMu)) { this.InitMu = initVals.Mu; } if (testSD) { this.InitSD = initVals.SigmaWithin; } } if (this.ME.ThroughCV) { this.Result.Chains.Add("cv"); } }// end constructor
internal override double LogFPrime(double mu, SGNFnAParam A) { double z = mu / A.S; LPhiObject lphio = WebExpoFunctions3.LPhi(z); return(-A.N * (mu - A.MuMean) / A.S2 - A.N * lphio.R[0] / A.S); }
internal override double LogFSecond(double s, SGNFnAParam A) { double z = A.Mu / s; LPhiObject l = WebExpoFunctions3.LPhi(z); return(A.N / Math.Pow(s, 2) - 6.0 * A.B / Math.Pow(s, 4) + A.N * z * ((Math.Pow(z, 2) - 2.0) * l.R[0] + z * l.R2[0]) / Math.Pow(s, 2)); }
internal override double LogFPrime(double s, SGNFnAParam A) { double z = A.Mu / s; LPhiObject l = WebExpoFunctions3.LPhi(z); return(-A.N / s + 2.0 * A.B / Math.Pow(s, 3) + A.N * z * l.R[0] / s); }
internal override double LogFPrime(double v, SGNFnAParam A) { LPhiObject l = WebExpoFunctions3.LPhi(1 / v); return (-A.N / v + 2.0 * A.B / Math.Pow(v, 3) + A.N * l.R[0] / Math.Pow(v, 2)); }
internal static MEParmGen GetInstance(GenObject o, MeasurementError me, DataSummary data, YGen genY, TrueValuesGen genTV) { MEParmGen instance = new MEParmGen(); double b; double[] tmpY, tmpT; if (me.ThroughCV) { if (o.LogNormalDistrn) { tmpY = Tools.Combine(data.LogY, genY.LogGT, genY.LogLT, genY.LogI); tmpT = Tools.Combine(genTV.LogY, genTV.LogGT, genTV.LogLT, genTV.LogI); b = tmpY.Substract(tmpT).Exp().Substract(1.0).Sqr().Sum(); b /= 2.0; } else { tmpY = Tools.Combine(data.Y, genY.GT, genY.LT, genY.I); tmpT = Tools.Combine(genTV.Y, genTV.GT, genTV.LT, genTV.I); b = tmpY.Divide(tmpT).Substract(1.0).Sqr().Reverse().Sum(); b /= 2.0; } SGNFnAParam localA = o.A.Clone(); localA.B = b; localA.Range = me.GetRange(); double[] range = me.GetRange(); Icdf icdf = new Icdf(o, localA, range); instance.Parm = icdf.Bidon(o.Start(localA), inestLowerLim: range[0] == 0); } else { tmpY = Tools.Combine(data.Y, genY.GT, genY.LT, genY.I); tmpT = Tools.Combine(genTV.Y, genTV.GT, genTV.LT, genTV.I); b = tmpY.Substract(tmpT).Sqr().Sum(); b /= 2.0; if (o.LogNormalDistrn) { SGNFnAParam localA = o.A.Clone(); localA.B = b; localA.Range = me.GetRange(); localA.Truevalues = Tools.Copy(tmpT); //me.parm <- dens.gen.icdf(o, A, range=me$range, inestimable.lower.limit=me$range[1]==0) double[] range = me.GetRange(); Icdf icdf = new Icdf(o, localA, range); instance.Parm = icdf.Bidon(inestLowerLim: range[0] == 0.0); } else { instance.Parm = WebExpoFunctions3.SqrtInvertedGammaGen(data.N, b, me.GetRange(), o); } } return(instance); }
internal override double LogFSecond(double s, SGNFnAParam A) { // log.f.prime <- function(s, A){z <- exp(s)/A$ksi; l <- lphi(z); -l$r*z + A$y*z/A$ksi - z^2 - (s-A$mu)/A$sigma2} double[] z = new double[] { Math.Exp(s) / A.Ksi }; LPhiObject lphio = WebExpoFunctions3.LPhi(z); double r0 = lphio.R[0]; double z0 = z[0]; return(r0 * (Math.Pow(z0, 3) - z[0]) + Math.Pow(r0 * z0, 2) + (A.Y * Math.Exp(s) - 2.0 * Math.Exp(2 * s)) / A.Ksi2 - 1.0 / A.Sigma2); }
internal override double LogFSecond(double v, SGNFnAParam A) { LPhiObject l = WebExpoFunctions3.LPhi(1 / v); double v2 = Math.Pow(v, 2); double v4 = Math.Pow(v2, 2); return (A.N / v2 - 6.0 * A.B / v4 + A.N / v4 * (l.R[0] * (1 / v - 2.0 * v) + l.R2[0])); }
internal override double LogFPrime(double s, SGNFnAParam A) { double z = A.Mu / s; LPhiObject l = WebExpoFunctions3.LPhi(z); return (-(A.N + 1.0) / s + 2.0 * A.B / Math.Pow(s, 3) - (Math.Log(s) - A.LM) / A.LS2 / s + A.N * z * l.R[0] / s); }
internal override double LogFPrime(double s, SGNFnAParam A) { // log.f.prime <- function(s, A){z <- exp(s)/A$ksi; l <- lphi(z); -l$r*z + A$y*z/A$ksi - z^2 - (s-A$mu)/A$sigma2} double z = Math.Exp(s) / A.Ksi; LPhiObject lphio = WebExpoFunctions3.LPhi(z); return (-lphio.R[0] * z + A.Y * z / A.Ksi - Math.Pow(z, 2) - (s - A.Mu) / A.Sigma2); }
public double Bidon() { ReferencePoints rp = new ReferencePoints(this.Ob01, this.A, this.Start.Copy(), this.Range, this.InestimableLowerLimit, epsilon: this.Precision); LModeExt refPtsMode = rp.GetPoints(); bool cntn = false; double uMode; double x; double target; double areaMode; bool distrnLeftSide = false; double mathLowerLimit = this.Ob01.MathLowerLimit; bool converged = false; double areaX; double precision = this.Precision; Func <double, SGNFnAParam, double> area; if (refPtsMode.Found) { // A$f < -o$f this.A.F = this.Ob01.F; this.A.LowerLimit = refPtsMode.Remote[0]; this.A.M = refPtsMode.H; // # (kind of a) standardizing constant area = this.A.AreaFnFromALLimToX; double areaTot = WebExpoFunctions3.SmoothedAreaEstimate( area, refPtsMode.Remote[1], this.A, mathLowerLimit, refPtsMode.Remote, this.InestimableLowerLimit, remoteRight: true); target = this.U * areaTot; precision = this.Precision * areaTot; x = refPtsMode.X; areaX = 0; areaMode = WebExpoFunctions3.SmoothedAreaEstimate(area, x, this.A, mathLowerLimit, refPtsMode.Remote, this.InestimableLowerLimit); uMode = areaMode / areaTot; converged = Math.Abs(areaMode - target) < precision; cntn = !converged; } else { throw new WEException("Mode not found"); } if (cntn) { distrnLeftSide = this.U < uMode; if (distrnLeftSide) { area = this.A.AreaFn_FromXToAULim; this.A.UpperLimit = refPtsMode.X; this.Range = Tools.Combine(refPtsMode.Remote[0], refPtsMode.X); } else { this.A.LowerLimit = refPtsMode.X; this.Range = Tools.Combine(refPtsMode.X, refPtsMode.Remote[1]); } } //converged = true; if (cntn && this.Ob01.PotentiallyBimodal) { // Slower but safer algorithm for posterior distrns that are potentially bimodal double fMode = A.F(refPtsMode.X, A); double start = refPtsMode.X + (target - areaMode) / fMode; cntn = false; converged = true; // voir l'impact !!! double highestPoint; double hMax; if (distrnLeftSide) { highestPoint = refPtsMode.Remote[0]; hMax = areaMode; target = (uMode - this.U) / uMode * hMax; } else { highestPoint = refPtsMode.Remote[1]; hMax = WebExpoFunctions3.SmoothedAreaEstimate(area, refPtsMode.Remote[1], this.A, mathLowerLimit, this.Range, this.InestimableLowerLimit, remoteRight: true); target = (this.U - uMode) / (1 - uMode) * hMax; } SecuredNRA oCum = new SecuredNRA(area, this.Ob01.F); SecuredNRSearch nr = new SecuredNRSearch(oCum, this.A, start, precision, this.Range, maxPoint: new LMode(highestPoint, hMax), target: target, inestimableLowerLimit: this.InestimableLowerLimit); // le dernier paramètre a une valeur par défaut: expectedHpSign = -1 if (nr.Converged) { x = nr.X; } else { //# it seems we were caught in an infinite loop, had we not limited the number of iterations; //# see if we can rule that problem out x = nr.Bounds.X[0]; double h = nr.Bounds.H[0]; x = ICDFFunctions.PingpongTieBreaker(area, this.A, x, h, target, mathLowerLimit, this.Range, this.InestimableLowerLimit, precision, distrnLeftSide); } } int direction = 0; int count = 0; if (cntn) { direction = distrnLeftSide ? -1 : 1; if (distrnLeftSide) { target = (uMode - this.U) / uMode * areaMode; } else { double areaRemoteRight = WebExpoFunctions3.SmoothedAreaEstimate( area, refPtsMode.Remote[1], this.A, mathLowerLimit, this.Range, this.InestimableLowerLimit, remoteRight: true); target = (this.U - uMode) / (1 - uMode) * areaRemoteRight; } } while (cntn) { double hp = this.Ob01.F(x, A); double change = (target - areaX) / hp * direction; x = x + change; areaX = area(x, A); count = count + 1; converged = Math.Abs(areaX - target) < precision; cntn = !converged && count <= this.NRMaxIter; } if (!converged) { if (x > refPtsMode.Remote[1] || x < refPtsMode.Remote[0]) { throw new WEException("Stepped out of bounds -- due to numerical imprecision?"); } else { //# it seems we were caught in an infinite loop, had we not limited the number of iterations; //# see if we can rule that problem out x = ICDFFunctions.PingpongTieBreaker(area, this.A, x, areaX, target, mathLowerLimit, this.Range, this.InestimableLowerLimit, precision, distrnLeftSide); } } return(x); }
}// 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
internal static double PingpongTieBreaker( Func <double, SGNFnAParam, double> area, SGNFnAParam A, double start, double areaX, double target, double mathLowerLimit, double[] refRange, bool inestimableLowerLimit, double epsilon, bool distrnLeftSide = false, int maxCount = 100) { int hpMult = distrnLeftSide ? -1 : 1; bool cntn = true; int count = 0; double x = start; Visits visitedX = new Visits(maxCount); visitedX.Add(x); bool converged = false; bool caughtInLoop = false; while (cntn) { double hp = A.F(x, A) * hpMult; double change = (target - areaX) / hp; x = x + change; // new_0.11 if (x < refRange[0]) { x = (refRange[0] == mathLowerLimit) && inestimableLowerLimit ? (x - change + mathLowerLimit) / 2.0 : refRange[0]; } areaX = WebExpoFunctions3.SmoothedAreaEstimate(area, x, A, mathLowerLimit, refRange, inestimableLowerLimit, hpMult: hpMult); count++; converged = Math.Abs(areaX - target) < epsilon; visitedX.Add(x); caughtInLoop = visitedX.CaughtInLoop; // La propiété CaughtInLoop est mise à jour à chaque ajout d'un x. // x doit être fini, et avoir déjà été visité. cntn = !converged && (visitedX.Count <= maxCount) && !caughtInLoop; } if (!converged && caughtInLoop) { // We have found the series of points that are repeatedly visited: // recalibrate and try Newton-Raphson again double[] tail = visitedX.GetFromTail(x); x = (distrnLeftSide) ? x = tail.Max() : tail.Min(); areaX = WebExpoFunctions3.SmoothedAreaEstimate(area, x, A, mathLowerLimit, refRange, inestimableLowerLimit, hpMult: hpMult); if (distrnLeftSide) { A.UpperLimit = x; } else { A.LowerLimit = x; } target = target - areaX; areaX = 0.0; count = 0; cntn = true; while (cntn) { double hp = A.F(x, A) * hpMult; double change = (target - areaX) / hp; x = x + change; areaX = area(x, A); count = count + 1; converged = Math.Abs(areaX - target) < epsilon; cntn = !converged && (count <= maxCount); } } if (!converged) { //TODO Exception throw new WEException("Newton-Raphson algorithm did not converge. Sorry.\n"); } return(x); } // end of ping.pong.tie.breaker
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; } }