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
//Tools.Combine(-0.693147180559945, 0.797884560802865, -0.318309886183791, 0.0363356023574984); // logPhi.quadratic.approx.coeff
internal static InitialValues DefaultInits(DataSummary data, bool logNormalDistrn, double[] muRange, double[] sigmaRange, bool includeCensoredData)
{
//# modif_0.13
//# added argument include.censored.data to this fct
double mu;
double sigma;
double sigmaLower = sigmaRange.Min();
double sigmaUpper = sigmaRange.Max();
List <double> normalizedY = new List <double>();
if (data.YLength > 0)
{
normalizedY.AddRange(logNormalDistrn ? data.LogY : data.Y);
}
// new_0.12
if (includeCensoredData)
{
if (data.GTLength > 0)
{
normalizedY.AddRange(logNormalDistrn ? data.LogGT : data.GT);
}
if (data.LTLength > 0)
{
normalizedY.AddRange(logNormalDistrn ? data.LogLT : data.LT);
}
if (data.IntervalLength > 0)
{
double[] midPoints = new double[data.IntervalLength];
double[] lt = logNormalDistrn ? data.LogIntervalLT : data.IntervalLT;
double[] gt = logNormalDistrn ? data.LogIntervalGT : data.IntervalGT;
for (int i = 0; i < data.IntervalLength; i++)
{
midPoints[i] = gt[i] + (lt[i] - gt[i]) / 2.0;
}
normalizedY.AddRange(midPoints);
}
}
if (data.YLength > 0)
{
mu = normalizedY.Mean();
double lower = muRange.Min();
if (mu < lower)
{
mu = lower;
}
else
{
double muUpper = muRange.Max();
if (mu > muUpper)
{
mu = muUpper;
}
}
if (normalizedY.Count > 1)
{
sigma = Math.Sqrt(normalizedY.Variance());
}
else if (!includeCensoredData)
{
InitialValues tmp = DefaultInits(data, logNormalDistrn, muRange, sigmaRange, includeCensoredData: true);
sigma = tmp.SigmaWithin;
}
else
{
//# new_0.13
sigma = 0; //# will be corrected below
}
if (sigma < sigmaLower)
{
sigma = sigmaLower;
}
// sigma >= 0 && sigma >= sigmaLower
if (sigma == 0.0)
{
// sigmaLower <= 0 !!
sigma = sigmaUpper / 10.0;
}
}
else
{
sigma = sigmaLower > 0 ? sigmaLower : sigmaUpper / 10.0;
mu = Tools.Mean(muRange);
}
return(new InitialValues(mu, sigma));
} // Default.inits
internal InitialValues DefaultInits(DataSummary data, bool includeCensoredData)
{
double muOverall = Tools.ND;
double sigmaWithin = Tools.ND;
bool logNormalDstrn = this.LogNormalDstrn;
bool useUniformPriorOnSds = this.UseUniformPriorOnSds;
List <double> workerMeans = new List <double>();
List <double> workerSds = new List <double>();
List <double> normalizedData = new List <double>();
int[] MeasureCountByWorker = new int[data.NWorkers];
Dictionary <int, List <double> > measureValueByWorker = new Dictionary <int, List <double> >();
if (data.YLength > 0)
{
//Une liste pour chaque travailleurs. wo == workerOrdinal
for (int wo = 0; wo < data.NWorkers; wo++)
{
measureValueByWorker[wo] = new List <double>();
}
Measure[] lm;
//On ajoute les mesures pour chacun des travailleurs
lm = data.UncensoredMeasures;
for (int i = 0; i < lm.Length; i++)
{
int wo = lm[i].Worker.Ordinal;
List <double> lst = measureValueByWorker[wo];
double value = logNormalDstrn ? Math.Log(lm[i].A) : lm[i].A;
lst.Add(value);
normalizedData.Add(value);
}
}
if (includeCensoredData)
{
Measure[] lm;
lm = data.GTMeasures;
for (int i = 0; i < lm.Length; i++)
{
int wo = lm[i].Worker.Ordinal;
List <double> lst = measureValueByWorker[wo];
double value = logNormalDstrn ? Math.Log(lm[i].A) : lm[i].A;
lst.Add(value);
normalizedData.Add(value);
}
lm = data.LTMeasures;
for (int i = 0; i < lm.Length; i++)
{
int wo = lm[i].Worker.Ordinal;
List <double> lst = measureValueByWorker[wo];
double value = logNormalDstrn ? Math.Log(lm[i].A) : lm[i].A;
lst.Add(value);
normalizedData.Add(value);
}
lm = data.IntervalMeasures;
for (int i = 0; i < lm.Length; i++)
{
int wo = lm[i].Worker.Ordinal;
List <double> lst = measureValueByWorker[wo];
double midP = lm[i].A + (lm[i].B - lm[i].A) / 2;
double value = logNormalDstrn ? Math.Log(midP) : midP;
lst.Add(value);
normalizedData.Add(value);
}
}
if (normalizedData.Count > 0)
{
for (int o = 0; o < data.NWorkers; o++)
{
List <double> src = measureValueByWorker[o];
if (src.Count == 0)
{
continue;
}
if (src.Count == 1)
{
workerMeans.Add(src[0]);
continue; // pas de sd
}
int n = 0;
double mean = 0;
double M2 = 0;
foreach (double x in src)
{
n++;
double delta = x - mean;
mean += delta / n;
M2 += delta * (x - mean);
}
workerMeans.Add(mean);
if (n > 1)
{
workerSds.Add(Math.Sqrt(M2 / (n - 1)));
}
}
//means.Length > 0
muOverall = workerMeans.Average();
//# modif_0.13
if (workerSds.Count == 0)
{
if (workerMeans.Count > 1)
{
sigmaWithin = Math.Sqrt(workerMeans.Variance());
}
}
else
{
sigmaWithin = workerSds.Mean();
}
}
else
{
muOverall = 0.0;
normalizedData.Clear();
}
// # new_0.13
if (Tools.IsND(sigmaWithin) && !includeCensoredData)
{
//# call this fct again, but this time including censored data
InitialValues tmp = DefaultInits(data, includeCensoredData: true);
sigmaWithin = tmp.SigmaWithin;
}
// # new_0.13
if (Tools.IsND(sigmaWithin))
{
sigmaWithin = GetSigmaWithin();
}
return(new InitialValues(muOverall, sigmaWithin, normalizedData));
} //# end of Default.inits.local
public BetweenWorkerModel(MeasureList measures, AbstractBWModelParameters specificParams, McmcParameters mcmcParams = null)
: base(measures, specificParams.LogNormalDstrn, mcmcParams)
{
this.Result = new ModelResult(this, "muOverall", "sigmaWithin", "sigmaBetween");
if (!measures.IsWorkerInfoComplete)
{
this.Messages.AddError("Incomplete worker information.", this.ClassName);
}
if (this.Data.MEAny)
{
if (this.Data.METhroughSD && !MeasurementErrorSupport.MESD)
{
this.Messages.AddError("No support for METhrougSD.", this.ClassName);
}
else if (this.Data.METhroughCV && !MeasurementErrorSupport.me_CV)
{
this.Messages.AddError("No support for METhrougCV.", this.ClassName);
}
}
if (this.Messages.Level == Message.Severity.Error)
{
return;
}
this.UseUniformPriorOnSds = specificParams.UseUniformPriorOnSds;
if (this.UseUniformPriorOnSds)
{
this.SigmaBetweenRange = Tools.Copy(((BWModelParameters_UniformPriorOnSDs)specificParams).SigmaBetweenRange);
this.SigmaWithinRange = ((BWModelParameters_UniformPriorOnSDs)specificParams).SigmaWithinRange;
}
else
{
this.LogSigmaBetweenMu = ((BWModelParameters)specificParams).LogSigmaBetweenMu;
this.LogSigmaBetweenPrec = ((BWModelParameters)specificParams).LogSigmaBetweenPrec;
this.LogSigmaWithinMu = ((BWModelParameters)specificParams).LogSigmaWithinMu;
this.LogSigmaWithinPrec = ((BWModelParameters)specificParams).LogSigmaWithinPrec;
}
//4 paramètres communs aux 2 formes que prend le modèle.
this.MuOverallLower = specificParams.MuOverallLower;
this.MuOverallUpper = specificParams.MuOverallUpper;
this.InitMuOverall = specificParams.InitMuOverall;
this.InitSigmaWithin = specificParams.InitSigmaWithin;
this.MuOverallRange = Tools.Combine(this.MuOverallLower, this.MuOverallUpper);
this.Result.AddWorkerMuChains(Data.WorkersByTag.Values);
if (!Data.AnyCensored && UseUniformPriorOnSds)
{
//
//# If there is no variation observed within subjects,
//# then we require a non-null lower bound for sigma.within
//
if (SigmaWithinRange[0] == 0)
{
bool problem = (Data.NWorkers == Data.N); //il devrait donc y avoir plus d'une mesure pour au moins un travailleur
if (!problem)
{
problem = true;
foreach (KeyValuePair <Worker, List <Measure> > kv in Data.MeasuresByWorker)
{
if (kv.Value.Count <= 1)
{
continue;
}
//at least two measures
double vari = kv.Value.Select(x => x.A).Variance();
if (double.IsNaN(vari) || (vari == 0))
{
continue;
}
else
{
problem = false;
break;
}
} //foreach
}
if (problem)
{
this.Messages.AddError("Lower bound for SigmaWithinRange must be > 0 due to observed null within-subjects variance.", this.ClassName);
return;
}
}
}
if (specificParams.GetType() == typeof(BWModelParameters))// && (Tools.IsND(this.InitMuOverall) || Tools.IsND(this.InitSigmaWithin)))
{
InitialValues initValues = specificParams.DefaultInits(this.Data, includeCensoredData: false);
if (Tools.IsND(this.InitMuOverall))
{
this.InitMuOverall = initValues.Mu;
}
if (Tools.IsND(this.InitSigmaWithin))
{
this.InitSigmaWithin = initValues.SigmaWithin;
}
this.NormalizedY = initValues.NormalizedY.ToArray();
}
}
