private void setMoleculeStartValueFormula(IFormula formula, IMoleculeStartValue moleculeStartValue, IBuildingBlock moleculesStartValues)
{
if (!formula.IsConstant())
{
moleculeStartValue.Formula = _cloneManagerForBuildingBlock.Clone(formula, moleculesStartValues.FormulaCache);
}
}
private void renameAbsolutePathIn(IFormula formula)
{
if (formula == null || formula.IsConstant())
{
return;
}
formula.ObjectPaths.Where(isAbsolutePath).Each(renameObjectPath);
}
/// <summary>
/// add the given formula to the cache only if
/// 1- the formula is not constant (constant formula are not registered in cache)
/// 2- the formula was not registered already.
/// </summary>
/// <param name="formula">formula to add</param>
/// <param name="formulaCache">formula cache</param>
private void addFormulaToCacheIfNecessary(IFormula formula, IFormulaCache formulaCache)
{
if (formula.IsConstant())
{
return;
}
if (formulaCache.Contains(formula.Id))
{
return;
}
formulaCache.Add(formula);
}
private static void addFormualDescription(IFormula formula, StringBuilder description)
{
if (formula.IsConstant())
{
description.AppendLine($"{AppConstants.Captions.Value}: {((ConstantFormula) formula).Value.ToString(CultureInfo.InvariantCulture)}");
}
if (formula.IsExplicit())
{
description.AppendLine($"{AppConstants.Captions.Formula}:{((ExplicitFormula) formula).FormulaString}");
}
}
/// <summary>
/// Checks that the formula is equivalent for the start value. This includes evaluation of constant formula to a double
/// </summary>
/// <param name="startValue">The start value to check</param>
/// <param name="targetFormula">The formula being evaluated</param>
/// <returns>True if the formula is equivalent to the start value formula</returns>
public bool HasEquivalentFormula(IStartValue startValue, IFormula targetFormula)
{
var startValueFormula = startValue.Formula;
if (startValueFormula == null && targetFormula == null)
{
return(true);
}
if ((startValueFormula == null || startValueFormula.IsConstant()) && targetFormula.IsConstant())
{
return(isConstantFormulaEqualToStartValue(startValue, targetFormula.DowncastTo <ConstantFormula>()));
}
return(_formulaTask.FormulasAreTheSame(startValue.Formula, targetFormula));
}
protected void RemoveConstantFormula(XElement quantityElement, IFormula formula, string formulaAttributeName, SerializationContext serializationContext)
{
if (!formula.IsConstant())
{
return;
}
//we need to save the value and remove the formula attribute that won't be saved
var attribute = quantityElement.Attribute(formulaAttributeName);
if (attribute != null)
{
attribute.Remove();
}
//remove unused formula from cache that was saved automatically in the reference mapping
serializationContext.RemoveFormulaFromCache(formula);
}
public FormulaType MapFrom(IFormula formula)
{
if (formula == null)
{
return(FormulaType.Constant);
}
if (formula.IsAnImplementationOf <IDistributionFormula>())
{
return(FormulaType.Distribution);
}
if (formula.IsAnImplementationOf <TableFormula>())
{
return(FormulaType.Table);
}
return(formula.IsConstant() ? FormulaType.Constant : FormulaType.Rate);
}
public FormulaBuilderDTO MapFrom(IFormula formula)
{
if (formula == null)
{
return(FormulaBuilderDTO.NULL);
}
var dto = Map <FormulaBuilderDTO>(formula);
if (formula.IsConstant())
{
dto.FormulaString = ((ConstantFormula)formula).Value.ConvertedTo <string>();
}
else if (formula.IsExplicit())
{
dto.FormulaString = ((ExplicitFormula)formula).FormulaString;
}
dto.FormulaType = _resolver.TypeFor(formula);
dto.Dimension = formula.Dimension;
dto.ObjectPaths = _formulaUsablePathMapper.MapFrom(formula);
return(dto);
}
public DistributionFormulaType MapFrom(IFormula formula)
{
if (formula == null)
{
return(DistributionFormulaType.DiscreteDistribution);
}
if (formula.IsAnImplementationOf <DiscreteDistributionFormula>() || formula.IsConstant())
{
return(DistributionFormulaType.DiscreteDistribution);
}
if (formula.IsAnImplementationOf <UniformDistributionFormula>())
{
return(DistributionFormulaType.UniformDistribution);
}
if (formula.IsAnImplementationOf <NormalDistributionFormula>())
{
return(DistributionFormulaType.NormalDistribution);
}
if (formula.IsAnImplementationOf <LogNormalDistributionFormula>())
{
return(DistributionFormulaType.LogNormalDistribution);
}
throw new MoBiException(AppConstants.Exceptions.UnknownDistributedFormula(formula.GetType()));
}
protected override IFormula CreateFormulaCloneFor(IFormula srcFormula)
{
// constant formulas are always cloned
if (srcFormula.IsConstant())
{
return(CloneFormula(srcFormula));
}
// Check if target formula cache already contains the formula
// to be cloned. This can happen if we are cloning
// any substructure within the same building block
// In this case, all formulas are already present in the
// formula cache of this building block
if (_formulaCache.Contains(srcFormula.Id))
{
return(srcFormula);
}
// Check if the formula was already cloned. Return the cloned
// formula if so.
if (_clonedFormulasByOriginalFormulaId.Contains(srcFormula.Id))
{
return(_clonedFormulasByOriginalFormulaId[srcFormula.Id]);
}
// Formula is neither present in the passed formula cahce nor
// was already cloned. So create a new clone and insert it
// in both target formula cache and the cache of all cloned formulas
var clonedFormula = CloneFormula(srcFormula);
_formulaCache.Add(clonedFormula);
_clonedFormulasByOriginalFormulaId.Add(srcFormula.Id, clonedFormula);
return(clonedFormula);
}
public bool FormulasAreTheSame(IFormula firstFormula, IFormula secondFormula)
{
if (firstFormula == null && secondFormula == null)
{
return(true);
}
if (firstFormula == null || secondFormula == null)
{
return(false);
}
var firstType = firstFormula.GetType();
var secondType = secondFormula.GetType();
if (firstType != secondType)
{
return(false);
}
//nothing more to check for distributed formula or black box formula
if (firstFormula.IsDistributed() || firstFormula.IsBlackBox() || firstFormula.IsDynamic())
{
return(true);
}
if (firstFormula.IsConstant())
{
var firstConstFormula = firstFormula.DowncastTo <ConstantFormula>();
var secondConstFormula = secondFormula.DowncastTo <ConstantFormula>();
return(firstConstFormula.Value == secondConstFormula.Value);
}
if (firstFormula.IsExplicit())
{
var firstExplicit = firstFormula.DowncastTo <ExplicitFormula>();
var secondExplicit = secondFormula.DowncastTo <ExplicitFormula>();
if (!string.Equals(firstExplicit.FormulaString, secondExplicit.FormulaString))
{
return(false);
}
//check that formula have the same references using the same alias
var firstObjectPathCache = new Cache <string, IFormulaUsablePath>(x => x.Alias);
firstObjectPathCache.AddRange(firstExplicit.ObjectPaths);
var secondObjectPathCache = new Cache <string, IFormulaUsablePath>(x => x.Alias);
secondObjectPathCache.AddRange(secondExplicit.ObjectPaths);
if (firstObjectPathCache.Count() != secondObjectPathCache.Count())
{
return(false);
}
foreach (var keyValue in firstObjectPathCache.KeyValues)
{
if (!secondObjectPathCache.Contains(keyValue.Key))
{
return(false);
}
var path = secondObjectPathCache[keyValue.Key];
if (!path.Equals(keyValue.Value))
{
return(false);
}
}
}
return(true);
}
public void should_have_retrieved_the_formula_as_a_consant_formula()
{
_formula.IsConstant().ShouldBeTrue();
}
