public override double[] GetPriorProbabilities(OptimizationParameterList discreteParameters)
{
const double eps = 0.0001;
double[] priors = new double[NonMissingClassCount];
try
{
EigenPair eig = LinearAlgebra.ComputeSparseEigenPair(LinearAlgebra.Transpose(GetTransitionProbabilityMatrix(discreteParameters, 1)));
ComplexNumber[] eigenValues = eig.EigenValues;
for (int i = 0; i < 4; i++)
{
if (ComplexNumber.ApproxEqual(eigenValues[i], 1, eps))
{
priors = LinearAlgebra.Abs(LinearAlgebra.ComplexToDouble(LinearAlgebra.Transpose(eig.EigenVectors)[i]));
break;
}
}
priors = LinearAlgebra.Normalize(priors);
}
catch (Exception e)
{
throw new NotComputableException("Problem computing the prior: " + e.Message);
}
return(priors);
}
protected override double[][] DefaultDistribution(BranchOrLeaf branchOrLeaf, OptimizationParameterList discreteParameters)
{
double lambda = discreteParameters[(int)ParameterIndex.Lambda].Value;
double x = discreteParameters[(int)ParameterIndex.Equilibrium].Value;
// in phylogenies, Lambda = site-specific mutation rate (in literature, "gamma"), Length = time*average mutation rate,
// e^(-lambda*t) = Pr[no mutation), and 1 - e^(-lambda*t) = Pr[mutation]
double expExp = 1.0 - Math.Exp(-lambda * branchOrLeaf.Length);
//Debug.Assert(expExp > 0);
// in phylogenies, X = equilibrium frequency of this A.A.
double[][] yDist = new double[][] { new double[2], new double[2] };
yDist[0][1] = x * expExp; // Pr[mutation AND mutationToTrue]
yDist[0][0] = 1.0 - yDist[0][1]; // that is, Pr[mutation AND mutationToFalse] + Pr[no mutation] = (1-X)*expExp + (1 - expExp) = 1 - X*expExp
yDist[1][0] = (1 - x) * expExp; // Pr[mutation AND mutationToFalse]
yDist[1][1] = 1.0 - yDist[1][0];
#if DEBUG
//foreach (double[] dArr in yDist)
//{
// foreach (double d in dArr)
// Debug.Assert(!double.IsNaN(d) && d >= 0 && d <= 1);
//}
#endif
return(yDist);
}
public ConditionalGaussianDistributionParams CreateDistributionGaussianOrNull(
Leaf leaf,
OptimizationParameterList gaussianParameters,
Converter <Leaf, SufficientStatistics> predictorLeafToBoolStats)
{
if (leaf.Length == 0)
{
Debug.WriteLine("Branch length of zero observed");
}
// TODO: make continuous
BooleanStatistics hasPredictor = (BooleanStatistics)predictorLeafToBoolStats(leaf);
if (hasPredictor.IsMissing())
{
ConditionalGaussianDistributionParams.GetNullInstance();
//return null; // Predictor data is missing, so skip this leaf.
}
ConditionalGaussianDistributionParams plainConditionalDistribution = GetPlainConditionalGaussianDistribution(leaf, gaussianParameters);
if (!hasPredictor)
{
return(plainConditionalDistribution);
}
else
{
double delta = GetOffset(gaussianParameters);
ConditionalGaussianDistributionParams offsetConditionalDistribution = plainConditionalDistribution.AddOffsetToMean(delta);
return(offsetConditionalDistribution);
}
//return CreateDistributionGaussianOrNull(plainConditionalDistribution, hasPredictor, delta);
}
/// <summary>
/// Initialization assumptions: LambdaA and LambdaB are 1. ie, both bases are evolving at the average rate.
/// P_A = (1-P_B) = empiricalLeafMargin. Note however that the empiricalLeafMargin is measured for base a; base B could be entirely different.
/// However, we need to keep the interface the same as for the other DiscreteDistributions, so it's not clear how to pass that information
/// in. For now we assume symmetry.
/// </summary>
public override OptimizationParameterList GetParameters(bool useConditionalParameter)
{
//Random random = new Random();
//double pAB = rand.NextDouble();
//double pAb = (1 - pAB) * rand.NextDouble();
//double paB = (1 - pAB - pAb) * rand.NextDouble();
//double lA = 3000 * rand.NextDouble();
//double lB = 3000 * rand.NextDouble();
double pAB = InitialParamVals == null ? EmpiricalEquilibrium / 2 : InitialParamVals[(int)ParameterIndex.P_AB].Value;
double pAb = InitialParamVals == null ? EmpiricalEquilibrium / 2 : InitialParamVals[(int)ParameterIndex.P_Ab].Value;
double paB = InitialParamVals == null ? (1 - EmpiricalEquilibrium) / 2 : InitialParamVals[(int)ParameterIndex.P_aB].Value;
double lA = InitialParamVals == null ? 1 : InitialParamVals[(int)ParameterIndex.Lambda_A].Value;
double lB = InitialParamVals == null ? 1 : InitialParamVals[(int)ParameterIndex.Lambda_B].Value;
OptimizationParameterList optList = OptimizationParameterList.GetInstance();
optList.Add((int)ParameterIndex.P_AB, OptimizationParameter.GetProbabilityInstance("P_TT", pAB, true));
optList.Add((int)ParameterIndex.P_Ab, OptimizationParameter.GetProbabilityInstance("P_TF", pAb, true));
optList.Add((int)ParameterIndex.P_aB, OptimizationParameter.GetProbabilityInstance("P_FT", paB, true));
optList.Add((int)ParameterIndex.Lambda_A, OptimizationParameter.GetPositiveFactorInstance("Lambda_A", lA, true));
optList.Add((int)ParameterIndex.Lambda_B, OptimizationParameter.GetPositiveFactorInstance("Lambda_B", lB, true));
optList.SetCheckConditions(CheckParameterConstraints);
return(optList);
}
protected virtual EvaluationResults CreateDummyResults(int[] fisherCounts)
{
List <Score> nullScores = new List <Score>(NullDistns.Count);
foreach (DistributionDiscreteSingleVariable nullDistn in NullDistns)
{
OptimizationParameterList nullParams = nullDistn.GetParameters();
foreach (OptimizationParameter param in nullParams)
{
param.Value = double.NegativeInfinity;
}
Score nullScore = Score.GetInstance(0, nullParams, nullDistn);
nullScores.Add(nullScore);
}
OptimizationParameterList altParams = this.AltDistn.GetParameters();
foreach (OptimizationParameter param in altParams)
{
param.Value = double.NegativeInfinity;
}
Score altScore = Score.GetInstance(0, altParams, AltDistn);
return(EvaluationResultsDiscrete.GetInstance(this, nullScores, altScore, fisherCounts, ChiSquareDegreesOfFreedom));
}
public override double[] GetPriorProbabilities(OptimizationParameterList discreteParameters)
{
double[] priors = new double[2];
priors[(int)DistributionClass.True] = discreteParameters[(int)ParameterIndex.Equilibrium].Value;
priors[(int)DistributionClass.False] = 1 - priors[(int)DistributionClass.True];
return(priors);
}
//public override bool TryDeriveParametersFromFisherCounts(int[] fisherCounts, out OptimizationParameterList parameters)
//{
// parameters = null;
// if (fisherCounts.Length != 4)
// {
// return false;
// }
// int tt = fisherCounts[(int)TwoByTwo.ParameterIndex.TT];
// int tf = fisherCounts[(int)TwoByTwo.ParameterIndex.TF];
// int ft = fisherCounts[(int)TwoByTwo.ParameterIndex.FT];
// int ff = fisherCounts[(int)TwoByTwo.ParameterIndex.FF];
// int total = tt+tf+ft+ff;
// double predP = (double)(tt + tf) / total;
// double targP = (double)(tt + ft) / total;
// if (Math.Max(predP, targP) != 1 && Math.Min(predP, targP) != 0)
// {
// return false;
// }
// parameters = GetParameters();
// if (targP == 0 || targP == 1)
// {
// parameters[(int)ParameterIndex.Equilibrium].Value = targP;
// parameters[(int)ParameterIndex.Lambda].Value = 0;
// }
//}
private OptimizationParameterList GetParameters(bool useConditionalParameter, double empericalEq, OptimizationParameterList initParams)
{
if (initParams != null)
{
OptimizationParameterList cloneList = (OptimizationParameterList)initParams.Clone();
OptimizationParameter parameter1 = cloneList[(int)ParameterIndex.Predictor1];
parameter1.DoSearch = useConditionalParameter || PredictorParametersInSequence;
OptimizationParameter parameter2 = cloneList[(int)ParameterIndex.Predictor2];
parameter2.DoSearch = useConditionalParameter && Use2PredictorParameters;
if (!useConditionalParameter)
{
if (!PredictorParametersInSequence)
{
parameter1.Value = 0.0;
}
parameter2.Value = 0.0;
}
return(cloneList);
}
else
{
OptimizationParameterList optList = OptimizationParameterList.GetInstance();
optList.Add((int)ParameterIndex.Predictor1, OptimizationParameter.GetProbabilityInstance("selection_pressure", 0, useConditionalParameter || PredictorParametersInSequence));
optList.Add((int)ParameterIndex.Predictor2, OptimizationParameter.GetProbabilityInstance("secondary_selection_pressure", 0, useConditionalParameter && Use2PredictorParameters));
optList.Add((int)ParameterIndex.Lambda, OptimizationParameter.GetPositiveFactorInstance("lambda", 1, true));
optList.Add((int)ParameterIndex.Equilibrium, OptimizationParameter.GetProbabilityInstance("pi", empericalEq, true));
return(optList);
}
}
private static void ComputeIidScores(int[] fisherCounts, out List <Score> nullScores, out Score altScore)
{
int tt = fisherCounts[(int)TwoByTwo.ParameterIndex.TT];
int tf = fisherCounts[(int)TwoByTwo.ParameterIndex.TF];
int ft = fisherCounts[(int)TwoByTwo.ParameterIndex.FT];
int ff = fisherCounts[(int)TwoByTwo.ParameterIndex.FF];
int sum = SpecialFunctions.Sum(fisherCounts);
double pi0 = (double)(tt + tf) / sum;
double pi1 = (double)(tt + ft) / sum;
double ptt = (double)tt / sum;
double ptf = (double)tf / sum;
double pft = (double)ft / sum;
double pff = (double)ff / sum;
OptimizationParameterList nullParamsLeft = OptimizationParameterList.GetInstance(
OptimizationParameter.GetProbabilityInstance("Pi", pi0, true));
OptimizationParameterList nullParamsRight = OptimizationParameterList.GetInstance(
OptimizationParameter.GetProbabilityInstance("Pi", pi1, true));
OptimizationParameterList altParams = OptimizationParameterList.GetInstance(
OptimizationParameter.GetProbabilityInstance("P_TT", ptt, true),
OptimizationParameter.GetProbabilityInstance("P_TF", ptf, true),
OptimizationParameter.GetProbabilityInstance("P_FT", pft, true));
ComputeIidScoresGivenParams(fisherCounts, nullParamsLeft, nullParamsRight, altParams, out nullScores, out altScore);
}
public override IMessage InitializeMessage(Leaf leaf, OptimizationParameterList discreteParameters)
{
int stateCount = DiscreteDistribution.NonMissingClassCount;
double[] p = new double[stateCount];
if (IsMissing(leaf))
{
//If missing data, return 1 to ignore this branch.
for (int iParentState = 0; iParentState < stateCount; ++iParentState)
{
p[iParentState] = 1.0;
}
}
else
{
double[][] dist = DiscreteDistribution.CreateDistribution(leaf, discreteParameters, LeafToPredictorStatistics);
int distnClass = (DiscreteStatistics)LeafToTargetStatistics(leaf);
for (int iParentState = 0; iParentState < stateCount; ++iParentState)
{
p[iParentState] = dist[iParentState][distnClass];
}
}
MessageDiscrete message = MessageDiscrete.GetInstance(p);
return(message);
}
public double GetEquilibriumVariance(OptimizationParameterList gaussianParameters)
{
double AlphaVariance = gaussianParameters["AlphaVariance"].Value;
double alpha = gaussianParameters["Alpha"].Value;
return(AlphaVariance / alpha);
}
protected virtual OptimizationParameterList GetParameters(bool useConditionalParameter, bool zeroVariance)
{
// ignore the initial parameter settings.
OptimizationParameterList paramStart = OptimizationParameterList.GetInstance(
OptimizationParameter.GetPositiveFactorInstance("Alpha", 1, true),
//OptimizationParameter.GetProbabilityInstance("Alpha", .5, true),
OptimizationParameter.GetPositiveFactorInstance("Variance", 10000, true),
//OptimizationParameter.GetPositiveFactorInstance("AlphaVariance", 10000, true),
OptimizationParameter.GetTanInstance("Delta", 0, useConditionalParameter, -1000, 1000),
OptimizationParameter.GetTanInstance("Mean", 0, true, -1000, 1000),
zeroVariance ? OptimizationParameter.GetPositiveFactorInstance("vNoise", 0, false)
: OptimizationParameter.GetPositiveFactorInstance("vNoise", 75, true)
);
//TEMPORARY TESTING!!!!!!!
//paramStart["Alpha"].Value = 0.165267457;
//paramStart["AlphaVariance"].Value = 6952.429217;
//paramStart["Delta"].Value = -23.71002634;
//paramStart["Delta"].DoSearch = true;
paramStart["Mean"].Value = 24.71176471;
paramStart["Variance"].Value = 35.224;
//paramStart["vNoise"].Value = 35.4194535;
return(paramStart);
}
public bool CheckParameterConstraints(OptimizationParameterList parameters)
{
double P_AB = parameters[(int)ParameterIndex.P_AB].Value;
double P_Ab = parameters[(int)ParameterIndex.P_Ab].Value;
double P_aB = parameters[(int)ParameterIndex.P_aB].Value;
return(P_AB + P_Ab + P_aB <= 1);
}
private Score CombineScores(Score existingScore, Score newScoreToAdd, double pNewScoreToAdd)
{
OptimizationParameterList newAverageParamList = AverageParamLists(existingScore.OptimizationParameters, newScoreToAdd.OptimizationParameters, pNewScoreToAdd);
double newLL = existingScore.Loglikelihood + newScoreToAdd.Loglikelihood;
Score newScore = Score.GetInstance(newLL, newAverageParamList, existingScore.Distribution);
return(newScore);
}
public static MessageInitializerDiscrete GetInstance(
Converter <Leaf, SufficientStatistics> predictorClassFunction,
Converter <Leaf, SufficientStatistics> targetClassFunction,
DistributionDiscrete discreteDistribution,
OptimizationParameterList initParams,
IEnumerable <Leaf> fullLeafCollection)
{
return(new MessageInitializerDiscrete(SpecialFunctions.CreateSingletonList(predictorClassFunction), targetClassFunction, discreteDistribution, null, initParams, fullLeafCollection));
}
public static MessageInitializerDiscrete GetInstance(
Converter <Leaf, SufficientStatistics> singleVariableClassFunction,
DistributionDiscrete discreteDistribution,
OptimizationParameterList initParams,
IEnumerable <Leaf> fullLeafCollection)
{
List <Converter <Leaf, SufficientStatistics> > emptyList = new List <Converter <Leaf, SufficientStatistics> >();
return(new MessageInitializerDiscrete(emptyList, singleVariableClassFunction, discreteDistribution, null, initParams, fullLeafCollection));
}
private OptimizationParameterList AverageParamLists(OptimizationParameterList existingParamList, OptimizationParameterList newParamList, double pNewScoreToAdd)
{
OptimizationParameterList resultParamList = existingParamList.Clone();
foreach (OptimizationParameter param in newParamList)
{
param.Value = (1 - pNewScoreToAdd) * param.Value + pNewScoreToAdd * newParamList[param.Name].Value;
}
return(resultParamList);
}
protected override OptimizationParameterList GetParameters(bool useConditionalParameter, bool zeroVariance)
{
OptimizationParameterList parameters = base.GetParameters(useConditionalParameter, zeroVariance);
OptimizationParameter alpha = parameters["Alpha"];
alpha.Value = 10000;
//alpha.Value = double.PositiveInfinity;
alpha.DoSearch = false;
return(parameters);
}
public override OptimizationParameterList GetParameters(double[] parametersInPrintOrder)
{
OptimizationParameterList parameters = GetParameters(true);
parameters[(int)ParameterIndex.Lambda_A].Value = parametersInPrintOrder[0];
parameters[(int)ParameterIndex.Lambda_B].Value = parametersInPrintOrder[1];
parameters[(int)ParameterIndex.P_AB].Value = parametersInPrintOrder[2];
parameters[(int)ParameterIndex.P_Ab].Value = parametersInPrintOrder[3];
parameters[(int)ParameterIndex.P_aB].Value = parametersInPrintOrder[4];
return(parameters);
}
public override double[] GetPriorProbabilities(OptimizationParameterList discreteParameters)
{
//const double eps = 0.0001;
double[] priors = new double[4];
priors[(int)DistributionClass.TrueTrue] = discreteParameters[(int)ParameterIndex.P_AB].Value;
priors[(int)DistributionClass.TrueFalse] = discreteParameters[(int)ParameterIndex.P_Ab].Value;
priors[(int)DistributionClass.FalseTrue] = discreteParameters[(int)ParameterIndex.P_aB].Value;
priors[(int)DistributionClass.FalseFalse] = 1 - priors[0] - priors[1] - priors[2];
return(priors);
}
public OptimizationParameterList GetParameters(double[] parametersInPrintOrder)
{
OptimizationParameterList parameters = GetParameters(false, false);
parameters["Alpha"].Value = parametersInPrintOrder[0];
parameters["AlphaVariance"].Value = parametersInPrintOrder[1];
parameters["Delta"].Value = parametersInPrintOrder[2];
parameters["Mean"].Value = parametersInPrintOrder[3];
parameters["vNoise"].Value = parametersInPrintOrder[4];
return(parameters);
}
public override string GetParameterValueString(OptimizationParameterList parameters)
{
double eTimesLambdaA = parameters[(int)ParameterIndex.ETimesLambaA].Value;
double Lambda_Hla = parameters[(int)ParameterIndex.Lambda_Hla].Value;
double P_aa = parameters[(int)ParameterIndex.P_AA].Value;
double P_Hla = parameters[(int)ParameterIndex.P_Hla].Value;
double rTimesLambdaA = parameters[(int)ParameterIndex.RTimesLambdaA].Value;
//double P_r = parameters[(int)ParameterIndex.P_r].Value;
return(SpecialFunctions.CreateTabString(eTimesLambdaA, rTimesLambdaA, Lambda_Hla, P_aa, P_Hla));
}
public override OptimizationParameterList GetParameters(double[] parametersInPrintOrder)
{
OptimizationParameterList parameters = GetParameters(parametersInPrintOrder.Length >= 3, 0.5, null);
int nullParameterOffset = parametersInPrintOrder.Length - 2;
parameters[(int)ParameterIndex.Predictor1].Value = parametersInPrintOrder.Length == 2 ? 0 : parametersInPrintOrder[0];
parameters[(int)ParameterIndex.Predictor2].Value = parametersInPrintOrder.Length < 4 ? 0 : parametersInPrintOrder[1];
parameters[(int)ParameterIndex.Equilibrium].Value = parametersInPrintOrder[nullParameterOffset];
parameters[(int)ParameterIndex.Lambda].Value = parametersInPrintOrder[nullParameterOffset + 1];
return(parameters);
}
//public virtual bool UsePredictorVariable(bool useParameter)
//{
// return useParameter;
//}
public double[][] CreateDistribution(BranchOrLeaf branchOrLeaf, OptimizationParameterList discreteParameters,
Converter <Leaf, SufficientStatistics> predictorClassFunction)
{
if (branchOrLeaf is Branch)
{
return(CreateDistribution((Branch)branchOrLeaf, discreteParameters));
}
else
{
return(CreateDistribution((Leaf)branchOrLeaf, discreteParameters, predictorClassFunction));
}
}
protected MessageInitializerDiscrete(
List <Converter <Leaf, SufficientStatistics> > predictorClassFunctionList,
Converter <Leaf, SufficientStatistics> targetClassFunction,
DistributionDiscrete discreteDistribution,
int[] fisherCounts,
OptimizationParameterList initParams,
IEnumerable <Leaf> fullLeafCollection)
: base(predictorClassFunctionList, targetClassFunction, discreteDistribution, fullLeafCollection)
{
_fisherCounts = fisherCounts;
_initializationParams = initParams;
}
public ConditionalGaussianDistribution CreateDistributionGaussianOrNull(
BranchOrLeaf branchOrLeaf, OptimizationParameterList gaussianParameters, Converter <Leaf, SufficientStatistics> predictorLeafToBoolStats)
{
if (branchOrLeaf is Branch)
{
return(CreateDistributionGaussianOrNull((Branch)branchOrLeaf, gaussianParameters));
}
else
{
return(CreateDistributionGaussianOrNull((Leaf)branchOrLeaf, gaussianParameters, predictorLeafToBoolStats));
}
}
public override string GetParameterValueString(OptimizationParameterList parameters)
{
double lambdaA = parameters[(int)ParameterIndex.Lambda_A].Value;
double lambdaB = parameters[(int)ParameterIndex.Lambda_B].Value;
double P_AB = parameters[(int)ParameterIndex.P_AB].Value;
double P_Ab = parameters[(int)ParameterIndex.P_Ab].Value;
double P_aB = parameters[(int)ParameterIndex.P_aB].Value;
double P_ab = 1 - P_AB - P_Ab - P_aB;
double P_A = P_AB + P_Ab;
double P_B = P_AB + P_aB;
return(SpecialFunctions.CreateTabString(lambdaA, lambdaB, P_AB, P_Ab, P_aB, P_ab, P_A, P_B));
}
public override OptimizationParameterList GetParameters(double[] parametersInPrintOrder)
{
OptimizationParameterList parameters = GetParameters(true);
parameters[(int)ParameterIndex.ETimesLambaA].Value = parametersInPrintOrder[0];
parameters[(int)ParameterIndex.RTimesLambdaA].Value = parametersInPrintOrder[1];
parameters[(int)ParameterIndex.Lambda_Hla].Value = parametersInPrintOrder[2];
parameters[(int)ParameterIndex.P_AA].Value = parametersInPrintOrder[3];
parameters[(int)ParameterIndex.P_Hla].Value = parametersInPrintOrder[4];
//if (parametersInPrintOrder.Length == 6)
// parameters[(int)ParameterIndex.P_r].Value = parametersInPrintOrder[5];
return(parameters);
}
public override OptimizationParameterList GetParameters(int[] fisherCounts, OptimizationParameterList initParams)
{
double pAB, pAb, paB, lA, lB;
if (initParams != null)
{
pAB = initParams[(int)ParameterIndex.P_AB].Value;
pAb = initParams[(int)ParameterIndex.P_Ab].Value;
paB = initParams[(int)ParameterIndex.P_aB].Value;
lA = initParams[(int)ParameterIndex.Lambda_A].Value;
lB = initParams[(int)ParameterIndex.Lambda_B].Value;
}
else if (fisherCounts.Length == 4)
{
double sum = (double)SpecialFunctions.Sum(fisherCounts);
lA = lB = 1;
pAB = fisherCounts[(int)TwoByTwo.ParameterIndex.TT];
pAb = fisherCounts[(int)TwoByTwo.ParameterIndex.TF];
paB = fisherCounts[(int)TwoByTwo.ParameterIndex.FT];
}
else if (fisherCounts.Length == 2) // primarily for backward compatability testing
{
double empiricalEquilibrium = (double)fisherCounts[(int)DistributionDiscreteConditional.DistributionClass.True] / (fisherCounts[0] + fisherCounts[1]);
lA = lB = 1;
pAB = empiricalEquilibrium / 2;
pAb = empiricalEquilibrium / 2;
paB = (1 - empiricalEquilibrium) / 2;
}
else
{
throw new ArgumentException("Cannot parse fisher counts of length " + fisherCounts.Length);
}
//double pAB = initParams == null ? empiricalEquilibrium / 2 : initParams[(int)ParameterIndex.P_AB].Value;
//double pAb = initParams == null ? empiricalEquilibrium / 2 : initParams[(int)ParameterIndex.P_Ab].Value;
//double paB = initParams == null ? (1 - empiricalEquilibrium) / 2 : initParams[(int)ParameterIndex.P_aB].Value;
//double lA = initParams == null ? 1 : initParams[(int)ParameterIndex.Lambda_A].Value;
//double lB = initParams == null ? 1 : initParams[(int)ParameterIndex.Lambda_B].Value;
OptimizationParameterList optList = OptimizationParameterList.GetInstance();
optList.Add((int)ParameterIndex.P_AB, OptimizationParameter.GetProbabilityInstance("P_TT", pAB, true));
optList.Add((int)ParameterIndex.P_Ab, OptimizationParameter.GetProbabilityInstance("P_TF", pAb, true));
optList.Add((int)ParameterIndex.P_aB, OptimizationParameter.GetProbabilityInstance("P_FT", paB, true));
optList.Add((int)ParameterIndex.Lambda_A, OptimizationParameter.GetPositiveFactorInstance("Lambda_A", lA, true));
optList.Add((int)ParameterIndex.Lambda_B, OptimizationParameter.GetPositiveFactorInstance("Lambda_B", lB, true));
optList.SetCheckConditions(CheckParameterConstraints);
return(optList);
}
public override OptimizationParameterList GenerateInitialParams(OptimizationParameterList var1Params, OptimizationParameterList var2Params)
{
OptimizationParameterList initParams = GetParameters();
double pA = var1Params[(int)DistributionDiscreteConditional.ParameterIndex.Equilibrium].Value;
double pB = var2Params[(int)DistributionDiscreteConditional.ParameterIndex.Equilibrium].Value;
initParams[(int)ParameterIndex.Lambda_A].Value = var1Params[(int)DistributionDiscreteConditional.ParameterIndex.Lambda].Value;
initParams[(int)ParameterIndex.Lambda_B].Value = var2Params[(int)DistributionDiscreteConditional.ParameterIndex.Lambda].Value;
initParams[(int)ParameterIndex.P_AB].Value = pA * pB;
initParams[(int)ParameterIndex.P_Ab].Value = pA * (1 - pB);
initParams[(int)ParameterIndex.P_aB].Value = (1 - pA) * pB;
return(initParams);
}
/// <summary>
/// Sets the initial parameter values to the independent model under the two given models.
/// </summary>
/// <param name="independent1"></param>
/// <param name="independent2"></param>
public virtual void SetInitialParams(OptimizationParameterList predictorParams, OptimizationParameterList targetParams)
{
OptimizationParameterList initParams = GetParameters(false);
double pA = predictorParams[(int)DistributionDiscreteBinary.ParameterIndex.Equilibrium].Value;
double pB = targetParams[(int)DistributionDiscreteBinary.ParameterIndex.Equilibrium].Value;
initParams[(int)ParameterIndex.Lambda_A].Value = predictorParams[(int)DistributionDiscreteBinary.ParameterIndex.Lambda].Value;
initParams[(int)ParameterIndex.Lambda_B].Value = targetParams[(int)DistributionDiscreteBinary.ParameterIndex.Lambda].Value;
initParams[(int)ParameterIndex.P_AB].Value = pA * pB;
initParams[(int)ParameterIndex.P_Ab].Value = pA * (1 - pB);
initParams[(int)ParameterIndex.P_aB].Value = (1 - pA) * pB;
InitialParamVals = initParams;
}
