// FILE. . . . . d:/hak/hlt/src/hlt/fot/fuz/ArgumentPositionMapping.java
// EDIT BY . . . Hassan Ait-Kaci
// ON MACHINE. . Hak-Laptop
// STARTED ON. . Sun Jul 15 07:37:57 2018
/**
* @version Last modified on Wed May 15 05:07:48 2019 by hak
* @author Hassan Aït-Kaci
* @copyright © by the author
*/
package hlt.fot.fuz;
import hlt.fot.Functor;
import hlt.language.util.SetOf;
import hlt.language.util.ArrayList;
import hlt.language.util.IntArrayList;
/**
* This class represents an argument-position mapping as a set of pairs
* between distinct but α-similar Functors for each admissible
* fuzzy degree α in the defined functor similarity.
*
* @see ../Signature
* @see ../Functor
* @see SignatureSimilarity
*
*/
public class ArgumentPositionMapping
{
/**
* This mapping's fuzzy degree. It is initialized in the
* constructor and never changes.
*/
private double degree;
/**
* Returns this mapping's fuzzy degree.
*/
public double degree ()
{
return degree;
}
/**
* The position maps this mapping is part of.
*/
private ArgumentPositionMaps positionMaps;
/**
* Returns the position maps this mapping is part of.
*/
public ArgumentPositionMaps positionMaps ()
{
return positionMaps;
}
/**
* The index in positionMaps.argumentMappings() of
* this mapping.
*/
private int mappingIndex;
/**
* Returns the index in positionMaps.argumentMappings() of
* this mapping.
*/
public int mappingIndex ()
{
return mappingIndex;
}
public void setMappingIndex (int index)
{
mappingIndex = index;
}
private int degreeIndex;
/**
* Returns the index in similarity().degrees() of this
* mapping's fuzzy degree.
*/
public int degreeIndex ()
{
return degreeIndex;
}
/* ************************************************************************ */
/**
* Returns the similarity this refers to.
*/
public SignatureSimilarity similarity ()
{
return positionMaps.similarity();
}
/**
* Returns the similarity's signature.
*/
public SimilarFunctorSignature signature ()
{
return similarity().signature();
}
/* ************************************************************************ */
///////////////////////
// FROM functor data //
///////////////////////
/**
* This mapping's "from" Functor. It is initialized in the
* constructor and never changes.
*/
private Functor from;
/**
* Returns the "from" function symbol (a Functor) of this
* ArgumentPositionMapping.
*/
public Functor from ()
{
return from;
}
/**
* The ArrayList domainPositions is a list of
* mutually distinct Integer objects. Its size is equal to
* from.arity(). Each Integer element at index
* i in this list, 0 ≤ i <
* from.arity(), has an int value equal to
* i+1. It is initialized in the constructor and is never
* modified thereafter because it serves as the base structure for the
* set domain.
*/
private ArrayList domainPositions;
/**
* The full set of Integer elements of
* domainPositions of the from functor representing
* {1,..., from.arity()}. It is initialized in the
* constructor and never changes.
*/
private SetOf fullDomainPositions;
/**
* A set of Integer elements of domainPositions of
* the from functor. It is initialized by default in the
* constructor to the set
* {1,...,Math.min(from.arity(),to.arity())} but can be
* modified using the defineMapping method.
*/
private SetOf domain;
/**
* Returns the domain of this mapping as a set of positions if one is
* defined, or null if from.arity() = 0;
* otherwise sets domain to the set {1, ...,
* Math.min(from.arity(),to.arity())} and returns it.
*/
public SetOf domain ()
{
if (domain != null)
return domain;
if (from.arity() == 0)
return null;
domain = new SetOf(domainPositions);
for (int pos = 0; pos < Math.min(from.arity(),to.arity()); pos++)
domain.add(domainPositions.get(pos));
return domain;
}
/**
* Sets this mapping's domain to the specified verified domain and
* returns it.
*/
public SetOf setDomain (SetOf domain)
{
return this.domain = verifiedDomain(domain);
}
/**
* Verifies that the specified set is a subset of from's full
* domain and that its number of elements does not exceed
* Math.min(from.arity(),to.arity()). If ok, it returns the
* domain. Otherwise, it throws an
* BadArgumentPositionMappingException with a detailed
* message.
*/
public SetOf verifiedDomain (SetOf domain)
{
if (!domain.isSubsetOf(fullDomainPositions) || domain.size() > Math.min(from.arity(),to.arity()))
throw new BadArgumentPositionMappingException
("fuzzy degree: "+degree+", "+
"from: "+from+", "+
"to: "+to+"; "+
"argument position map's domain "+domain+
" should be a subset of "+fullDomainPositions+
" and not exceed "+ Math.min(from.arity(),to.arity()));
return domain;
}
/* ************************************************************************ */
/////////////////////
// TO functor data //
/////////////////////
/**
* This mapping's "to" Functor.
*/
private Functor to;
/**
* Returns the "to" function symbol (a Functor) of this
* ArgumentPositionMapping. It is initialized in the
* constructor and never changes.
*/
public Functor to ()
{
return to;
}
/**
* The ArrayList rangePositions is a list of
* mutually distinct Integer objects. Its size is equal to
* to.arity(). Each Integer element at index
* i in this list, 0 ≤ i <
* to.arity(), has an int value equal to
* i+1. It is initialized in the constructor and is never
* modified thereafter because it serves as the base structure for the
* set range.
*/
private ArrayList rangePositions;
/**
* The full set of Integer elements of
* rangePositions of the to functor representing
* {1,...,to.arity()}. It is initialized in the constructor
* and never changes. It is initialized in the constructor and never
* changes.
*/
private SetOf fullRangePositions;
/**
* A set of Integer elements of rangePositions of
* the to functor. It is initialized by default in the
* constructor to the set
* {1,...,Math.min(from.arity(),to.arity())} but can be
* modified using the defineMapping method.
*/
private SetOf range;
/**
* Returns the range of this mapping as a set of positions if one is
* defined, or null if to.arity() = 0;
* otherwise sets range to the set {1, ...,
* Math.min(from.arity(),to.arity())} and returns it.
*/
public SetOf range ()
{
if (range != null)
return range;
if (from.arity() == 0)
return null;
range = new SetOf(rangePositions);
for (int pos = 0; pos < Math.min(from.arity(),to.arity()); pos++)
range.add(rangePositions.get(pos));
return range;
}
/**
* Sets this mapping's range to the specified verified range and
* returns it.
*/
public SetOf setRange (SetOf range)
{
return this.range = verifiedRange(range);
}
/**
* Verifies that the specified set is a subset of to's full
* range and that its number of elements does not exceed
* Math.min(from.arity(),to.arity()). If ok, it returns the
* domain. Otherwise, it throws an
* BadArgumentPositionMappingException with a detailed
* message.
*/
public SetOf verifiedRange (SetOf range)
{
if (!range.isSubsetOf(fullRangePositions) || range.size() > Math.min(from.arity(),to.arity()))
throw new BadArgumentPositionMappingException
("fuzzy degree: "+degree+", "+
"from: "+from+", "+
"to: "+to+"; "+
"argument position map's range "+range+
" should be a subset of "+fullRangePositions+
" and not exceed "+ Math.min(from.arity(),to.arity()));
return range;
}
/* ************************************************************************ */
//////////////////
// MAPPING data //
//////////////////
/**
* The two arrays mapping and inverse represent an
* ArgumentPositionMapping object. They are arrays of
* argument positions that correspond when comparing the distinct and
* degree-similar functors from and
* to. This correspondence must be injective. Therefore,
* these arrays are non-null only for a non-empty
* correspondence (i.e., when neither of the functors is a
* constant or when the similarity does not involve any arguments in
* either of the functors). Otherwise, they must be both defined and
* have equal length size ∈ {1, ...,
* Math.min(from.arity(),to.arity())}. If from's
* argument position i ∈ this.domain() and
* to's argument position j ∈
* this.range correspond, then there must be a unique
* k ∈ {0, ..., size-1} such that
* mapping[k] = j and inverse[k] = i.
*
*
*
* The arrays mapping and inverse are set by default
* to values that represent the identity on the largest set of
* argument positions common to from and to. So,
* size = Math.min(from.arity(),to.arity()) and
* domain = range = {1, ...,
* size}, such that for all k ∈ {0,
* ..., size-1}, mapping[k] = inverse[k] =
* k+1, since positions start at 1 while array
* indices start at 0.
*/
private int[] mapping;
private int[] inverse;
/**
* Returns true iff this argument position mapping is empty.
*/
public boolean isEmpty ()
{
return mapping == null;
}
/**
* Returns the size of this ArgumentPositionMapping.
*/
public int size ()
{
return isEmpty() ? 0 : mapping.length; // == inverse.length
}
/* ************************************************************************ */
/////////////////
// Constructor //
/////////////////
/**
* This constructs a new ArgumentPositionMapping object to be
* part of the specified ArgumentPositionMaps at
* approximation degree of index index in
* similarity().degrees() between Functor
* from and Functor to with the argument
* position map specified by positionPairs. It is constructed
* when invoked by the defineArgumentMapping(index,f,g,pairs)
* method in an ArgumentPositionMaps object maps
* where all the necessary info is to be registered and completed by
* closing the declared information when verified to be consistent.
*
*
If positionPairs is null, it is set to the
* identity on the set
* {1,...,Math.min(from.arity(),to.arity())}. Otherwise, it
* defines an argument-position mapping as a list of ints of
* the form [i1, j1, ..., in,
* jn]. If it contains valid argument position pairs
* for the from and to functors, it will define the
* set of domainPositions domain =
* {Integer.valueOf(i1), ..., Integer.valueOf(in)} and
* its set of rangePositions range =
* {Integer.valueOf(j1), ..., Integer.valueOf(jn)}, and
* also define the corresponding arrays of values of these positions
* mapping and inverse; otherwise, it throws a
* BadArgumentPositionMappingException with a detailed
* message.
*
*
For example, let us assume that from.arity() =
* 5 and to.arity() = 4, and that their
* argument mapping specifier is of size 3 and equal to:
* 2:4 5:2 3:1, which corresponds to the list of
* ints: [2, 4, 5, 2, 3, 1]. This will give:
*
* - domain = {Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(5)},
* - range = {Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(4)},
* - mapping = [2, 5, 3],
* - inverse = [4, 2, 1].
*
*
* Note that, while order and repeated elements do matter for lists,
* order is irrelevant for sets and there can be no repeated
* element. We shall display a list as a comma-separated sequence of
* their elements between square brackets, and display sets
* comma-separated sequences of their elements between curly braces.
*/
public ArgumentPositionMapping (ArgumentPositionMaps maps,
int index, Functor from, Functor to,
IntArrayList positionPairs)
{
// set this mapping's reference map (where it is defined):
positionMaps = maps;
// set the degree index to the specified int:
degreeIndex = index;
// set the approximation degree of this mapping (a double):
degree = maps.degrees().get(degreeIndex);
// set the source functor:
this.from = from;
// set the target functor:
this.to = to;
// a local shorthand for the source's arity
int fromArity = from.arity();
// a local shorthand for the target's arity
int toArity = to.arity();
// a local shorthand for the smaller arity between source and target
int minArity = Math.min(fromArity,toArity);
// a local shorthand for the larger arity between source and target
int maxArity = Math.max(fromArity,toArity);
// unique reference list for the corresponding domain set to be built:
domainPositions = Functor.argumentList(fromArity);
// unique reference list for the corresponding range set to be built:
rangePositions = Functor.argumentList(toArity);
// corresponding domain - a set of domain positions:
domain = new SetOf(domainPositions);
// corresponding range - a set of range positions:
range = new SetOf(rangePositions);
if (positionPairs == null) // no position pairs are specified
{
// set domain and range to the least set of positions by default:
for (int i = 0; i < minArity; i++)
{
Integer position = Integer.valueOf(i+1);
domain.add(position);
range.add(position);
}
// initialize this mapping and its inverse to the identity on
// {1,...,Math.min(from.arity(),to.arity())} by default:
if (minArity > 0)
{
mapping = new int[minArity];
inverse = new int[minArity];
for (int k = 0; k < minArity; k++)
mapping[k] = inverse[k] = k+1;
}
}
else // position pairs are specified
{
int cardinality = positionPairs.size() / 2; // since size is necessarily even
mapping = new int[cardinality];
inverse = new int[cardinality];
for (int i = 0; i < cardinality; i++)
{
domain.add(Integer.valueOf(mapping[i] = positionPairs.get(2*i)));
range.add(Integer.valueOf(inverse[i] = positionPairs.get(2*i+1)));
}
// verify that all argument positions are ok and actually define a one-to-one mapping:
if (domain.size() > fromArity)
throw new BadArgumentPositionMappingException
("fuzzy degree: "+degree+", "+
"from: "+from+", "+
"to: "+to+"; "+
"mapping domain too large for functor "+from+"/"+fromArity+": "+domain);
if (range.size() > toArity)
throw new BadArgumentPositionMappingException
("fuzzy degree: "+degree+", "+
"from: "+from+", "+
"to: "+to+"; "+
"mapping range too large for functor "+to+"/"+toArity+": "+range);
if (domain.size() != range.size())
throw new BadArgumentPositionMappingException
("fuzzy degree: "+degree+", "+
"from: "+from+", "+
"to: "+to+
"; non one-one argument-position mapping from :"+domain+" to "+range);
}
}
}