static private List <IntMapping> genMaps(int min_i, int min_j)
{
IntPair parameters = new IntPair(min_i, min_j);
List <IntMapping> resultMaps = new List <IntMapping>();
if (computedIntMaps.ContainsKey(parameters))
{
return(computedIntMaps[parameters]);
}
// base case: end with final link pair
if (min_i == a && min_j == b)
{
resultMaps.Add(new IntMapping());
return(resultMaps);
}
if (min_i < a && a > b)
{
List <IntMapping> subMaps = genMaps(min_i + 1, min_j);
foreach (IntMapping submap in subMaps)
{
IntPair x = new IntPair(min_i, min_j - 1);
IntMapping newMap = (IntMapping)submap.Clone();
newMap.mapPairs.Insert(0, x);
resultMaps.Add(newMap);
}
}
if (min_j < b && a < b)
{
List <IntMapping> subMaps = genMaps(min_i, min_j + 1);
foreach (IntMapping submap in subMaps)
{
IntPair x = new IntPair(min_i - 1, min_j);
IntMapping newMap = (IntMapping)submap.Clone();
newMap.mapPairs.Insert(0, x);
resultMaps.Add(newMap);
}
}
if (min_i < a && min_j < b)
{
List <IntMapping> subMaps = genMaps(min_i + 1, min_j + 1);
foreach (IntMapping submap in subMaps)
{
IntMapping newMap = (IntMapping)submap.Clone();
IntPair x = new IntPair(min_i, min_j);
newMap.mapPairs.Insert(0, x);
resultMaps.Add(newMap);
}
}
computedIntMaps[parameters] = resultMaps;
return(resultMaps);
}
public object Clone()
{
IntMapping map = new IntMapping();
foreach (IntPair p in this.mapPairs)
{
map.mapPairs.Add(p);
}
return(map);
}
/// <summary>
/// Tries to add the given relationship to the analogy, only one relationships of a particular type is allowed.
/// Requires relationships to conform to a valid left-to-right mapping!
/// If the relationships conflicts with any previous relationship, the previous is removed and replaced with the new one.
/// </summary>
/// <param name="reason"></param>
public bool TryToAddRelationship(Relationship relationship)
{
// Check for special case of LHS->RHS relationship, instead of subcomponent relationship.
if (relationship.LHS == LHS && relationship.RHS == RHS)
{
// This is fine; add it. (Note: replaces any previous relationship of same type).
AddRelationship(relationship);
return(true);
}
List <IntMapping> maps = IntMapping.getAllMaps(LHS.Count, RHS.Count);
// Make sure this relationship is valid in terms of the possible mappings that can occur left-to-right.
// It has to show up in one of the consistent maps.
List <IntMapping> consistentMaps = GetConsistentMaps(maps);
bool found = false;
int leftIdx = relationship.LHS.IndexInParent;
int rightIdx = relationship.RHS.IndexInParent;
foreach (IntMapping map in consistentMaps)
{
foreach (IntPair pair in map.mapPairs)
{
if (pair.x == leftIdx && pair.y == rightIdx)
{
found = true;
break;
}
}
if (found)
{
break;
}
}
// If not found, don't add.
if (!found)
{
return(false);
}
// No problems. Add it.
AddRelationship(relationship);
return(true);
}