/// <summary>
/// Add the consideration associated with the given Id.
/// </summary>
/// <param name="considerationId"></param>
/// <returns></returns>
public bool AddConsideration(string considerationId)
{
if (_collection == null)
{
return(false);
}
if (string.IsNullOrEmpty(considerationId))
{
return(false);
}
if (_considerations.Any(c => string.Equals(c.NameId, considerationId)))
{
return(false);
}
if (_collection.Contains(considerationId) == false)
{
return(false);
}
//InternalAddConsideration(considerationId);
//return true;
IConsideration consideration = _collection.Create(considerationId);
return(AddConsideration(consideration));
}
/// <summary>
/// Add the specified consideration
/// </summary>
/// <param name="consideration"></param>
/// <returns></returns>
public override bool AddConsideration(IConsideration consideration)
{
if (!base.AddConsideration(consideration))
{
return(false);
}
consideration.Parameters = Parameters?.Clone();
return(true);
}
public void AddConsideration(IConsideration <T> consideration)
{
if (considerationCount >= considerations.Length)
{
Array.Resize(ref considerations, considerationCount * 2);
}
considerations[considerationCount] = consideration;
considerationCount++;
}
void CreateConsiderations()
{
_aiConstructor.AIs.ClearAll();
_c1 = new OptionConsideration1("c1", _aiConstructor.Considerations);
_c2 = new OptionConsideration3("c2", _aiConstructor.Considerations);
_c3 = new OptionConsideration5("c3", _aiConstructor.Considerations);
_c4 = new OptionConsideration7("c4", _aiConstructor.Considerations);
_c5 = new OptionConsideration2("c5", _aiConstructor.Considerations);
_c6 = new OptionConsideration4("c6", _aiConstructor.Considerations);
_c7 = new OptionConsideration6("c7", _aiConstructor.Considerations);
_c8 = new OptionConsideration8("c8", _aiConstructor.Considerations);
}
bool Add(IConsideration consideration)
{
if (consideration == null)
{
return(false);
}
if (_considerationsMap.ContainsKey(consideration.NameId))
{
return(false);
}
_considerationsMap.Add(consideration.NameId, consideration);
return(true);
}
public bool Add(IConsideration consideration, IdInfoIndex id)
{
if (consideration == null || consideration.Equals(null))
{
return(false);
}
if (Contains(id))
{
return(false);
}
m_considerations.Add(id, consideration);
return(true);
}
/// <summary>
/// Adds the specified consideration.
/// </summary>
/// <param name="consideration">The consideration.</param>
/// <returns>
/// <c>true</c> if the consideration was successfully added to the collection, <c>false</c> otherwise.
/// </returns>
public bool Add(IConsideration consideration)
{
if (consideration == null)
{
return(false);
}
if (_considerationsMap.ContainsKey(consideration.NameId))
{
return(false);
}
if (string.IsNullOrEmpty(consideration.NameId))
{
return(false);
}
_considerationsMap.Add(consideration.NameId, consideration);
return(true);
}
/// <summary>
/// Add the specified consideration.
/// </summary>
/// <param name="consideration"></param>
/// <returns></returns>
public virtual bool AddConsideration(IConsideration consideration)
{
if (consideration == null)
{
return(false);
}
if (_considerations.Contains(consideration))
{
return(false);
}
if (_considerations.Any(c => string.Equals(c.NameId, consideration.NameId)))
{
return(false);
}
InternalAddConsideration(consideration);
return(true);
}
protected override IConsideration<T> SelectBestConsideration( T context )
{
var highestScore = this.DefaultConsideration.GetScore( context );
IConsideration<T> consideration = null;
for( var i = 0; i < this.Considerations.Count; i++ )
{
var score = this.Considerations[i].GetScore( context );
if( score > highestScore )
{
highestScore = score;
consideration = this.Considerations[i];
}
}
if( consideration == null )
return this.DefaultConsideration;
return consideration;
}
protected override IConsideration <T> selectBestConsideration(T context)
{
var highestScore = defaultConsideration.getScore(context);
IConsideration <T> consideration = null;
for (var i = 0; i < _considerations.Count; i++)
{
var score = _considerations[i].getScore(context);
if (score > highestScore)
{
highestScore = score;
consideration = _considerations[i];
}
}
if (consideration == null)
{
return(defaultConsideration);
}
return(consideration);
}
float ComputeConsiderationsValue(IConsideration c1, IConsideration c2, IConsideration c3, IConsideration c4)
{
var oA1List = new List <Utility>();
var oA2List = new List <Utility>();
c1.Consider(_optionContext);
c2.Consider(_optionContext);
c3.Consider(_optionContext);
c4.Consider(_optionContext);
oA1List.Add(c1.Utility);
oA1List.Add(c2.Utility);
oA2List.Add(c3.Utility);
oA2List.Add(c4.Utility);
var a1Util = new Utility(oA1List.Chebyshev(), 1.0f);
var a2Util = new Utility(oA2List.Chebyshev(), 1.0f);
var aList = new List <Utility>();
aList.Add(a1Util);
aList.Add(a2Util);
return(aList.Chebyshev());
}
public Reasoner <T> setDefaultConsideration(IConsideration <T> defaultConsideration)
{
this.defaultConsideration = defaultConsideration;
return(this);
}
public Reasoner <T> addConsideration(IConsideration <T> consideration)
{
_considerations.Add(consideration);
return(this);
}
void InternalAddConsideration(IConsideration c)
{
_considerations.Add(c);
_considerationUtilities.Add(new Utility(0.0f, 0.0f));
}
public void AddConsideration(IConsideration consideration)
{
_considerations.Add(consideration);
}
