public Formula(int size, int variables, Random random = null)
{
random ??= new Random();
for (var j = 0; j < size; j++)
{
Variable.Add(random.Next(variables));
Desired.Add(random.NextDouble() >= 0.5);
}
}
public override bool Equals(object obj)
{
return(obj is ImportModel model &&
Id == model.Id &&
Street == model.Street &&
Zip == model.Zip &&
NumberOfChildren == model.NumberOfChildren &&
Desired.SequenceEqual(model.Desired) &&
Unavailable.SequenceEqual(model.Unavailable));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Desired != null)
{
hashCode = hashCode * 59 + Desired.GetHashCode();
}
if (Reported != null)
{
hashCode = hashCode * 59 + Reported.GetHashCode();
}
return(hashCode);
}
}
/// <summary>
/// Merges the consumable into this model
/// </summary>
/// <param name="model"></param>
/// <param name="consumable"></param>
public void Merge(ImportModel consumable)
{
if (Desired == null)
{
Desired = consumable.Desired;
}
if (Unavailable == null)
{
Unavailable = consumable.Unavailable;
}
if (consumable.Desired != null)
{
Desired.AddRange(consumable.Desired);
}
if (consumable.Unavailable != null)
{
Unavailable.AddRange(consumable.Unavailable);
}
}
public override bool IsValid()
{
RuleFor(c => c.DtTrade)
.GreaterThan(DateTime.Now)
.WithMessage("Trade.DtTrade.GreaterThanNow");
RuleFor(c => c.Commited)
.Must(active => Enum.IsDefined(typeof(Commits), active) == true)
.WithMessage("Trade.Commited.MemberOfCommitsEnum");
RuleFor(c => c.Active)
.Must(active => Enum.IsDefined(typeof(Actives), active) == true)
.WithMessage("Trade.Active.MemberOfActivesEnum");
if (!UserGet.IsValid())
{
AddOtherErrorList(UserGet.ValidationResult.Errors);
}
if (!UserLet.IsValid())
{
AddOtherErrorList(UserLet.ValidationResult.Errors);
}
if (!Given.IsValid())
{
AddOtherErrorList(Given.ValidationResult.Errors);
}
if (!Desired.IsValid())
{
AddOtherErrorList(Desired.ValidationResult.Errors);
}
ValidateLocations();
ValidateEvaluations();
return(ValidationResult.IsValid);
}
/// <summary>
/// Returns true if DefinitionsJsontwin instances are equal
/// </summary>
/// <param name="other">Instance of DefinitionsJsontwin to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(DefinitionsJsontwin other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Desired == other.Desired ||
Desired != null &&
Desired.Equals(other.Desired)
) &&
(
Reported == other.Reported ||
Reported != null &&
Reported.Equals(other.Reported)
));
}
public bool IsSatisfied(BitArray bitArray) => Desired.Where((t, i) => bitArray[Variable[i]] == t).Any();
public void DeleteEmptyPeriods()
{
Desired?.RemoveAll(x => !Period.IsValid(x));
Unavailable?.RemoveAll(x => !Period.IsValid(x));
}
