private double TrueValueGen(GenObject genO, MeasurementError me, double y, double mu, double logY)
{
SGNFnAParam localA = genO.A.Clone();
localA.Mu = mu;
if (genO.LogNormalDistrn)
{
localA.LogY = logY;
}
localA.Y = y;
localA.Y2 = y * y;
if (genO.ThroughSD)
{
localA.Ksi = me.Parm;
localA.Ksi2 = me.Parm * me.Parm;
}
else
{
localA.CV2 = me.Parm * me.Parm;
}
double[] start = genO.Start(localA);
//start.Any(zz => !zz.IsFinite());
Icdf icdf = new Icdf(genO, localA, range: genO.Range);
double x = icdf.Bidon(start, inestLowerLim: !genO.LogNormalDistrn);
if (genO.LogNormalDistrn)
{
x = Math.Exp(x);// # new_0.11
}
return(x);
} //# end of truevalue.gen
//sqrt.invertedGamma.gen <- function(n, beta, xrange, o=list(), beta.min=1e-8)
internal static double SqrtInvertedGammaGen(int n, double beta, double[] xRange, GenObject o, double betaMin = 1E-8)
{
//# Sample a value from the distrn
//#
//# f(x) = 1
//# ------- . exp(-beta/x^2)
//# x^n
double x = Tools.ND;
if (n <= 1)
{
SGNFnAParam A = o.A.Clone();
A.B = beta;
Icdf icdf = new Icdf(o, A, xRange);
x = icdf.Bidon(start: Math.Sqrt(2.0 * beta), inestLowerLim: xRange[0] == 0);
}
else if (beta < betaMin)
{
if (xRange[0] == 0)
{
xRange[0] = 0.0001;
}
x = RandomPow(n, xRange);
}
else
{
double alpha = (n - 1) / 2.0;
double[] invX2Range = xRange.Sqr().Reverse().ToArray().Reciprocal();
double invX2 = RGammaTruncated(alpha, beta, invX2Range);
x = 1 / Math.Sqrt(invX2);
}
return(x);
} //# end of sqrt.invertedGamma.gen
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);
}
public static SigmaTruncatedDataGen GetInstance(GenObject o, double[] range, double b, double mu, double currentSigma)
{
SigmaTruncatedDataGen rep = new SigmaTruncatedDataGen();
SGNFnAParam localA = o.A.Clone();
localA.B = b;
localA.Mu = mu;
double[] start = o.Start(localA);
if (start.Length == 0)
{
start = Tools.Combine(currentSigma);
}
Icdf icdf = new Icdf(o, localA, range);
rep.Sigma = icdf.Bidon(start, inestLowerLim: range[0] == 0);
return(rep);
}
}// 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
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;
}
}