// FILE. . . . . d:/hak/hlt/src/hlt/fot/fuz/ArgumentMappingMatrix.java // EDIT BY . . . Hassan Ait-Kaci // ON MACHINE. . Hak-Laptop // STARTED ON. . Sat Dec 1 14:40:48 2018 // This is a "homomorphic" version of the class defined for fuzzy values in: // FILE. . . . . d:/hak/hlt/src/hlt/math/fuzzy/FuzzyMatrix.java package hlt.fot.fuz; import hlt.math.fuzzy.FuzzyMatrix; import hlt.language.util.IntArrayList; // for ... ??? // for the set of fuzzy degrees used by this fuzzy matrix (see end of file): import hlt.language.util.DoubleArrayList; /** * This is a class for a square matrix each element of which consists of * argument-position mappings from each functor to each functor at a * given approximation degree, a fuzzy value (i.e., a * double in the closed continuous interval * [0.0,1.0]). It is a subclass of SignatureSimilarity, * itself a subclass of hlt.math.fuzzy.FuzzyMatrix, * itself a subclass of hlt.math.matrix.Matrix. * It provides information on the functor-argument position mappings for * each similar pair of functors in the signature at each approximation * degree in degrees(), * which is a DoubleArrayList inherited from * FuzzyMatrix. It extends its parent class with validity * verification and closures operations on declared functor-argument * position mappings in addition to those it inherits on fuzzy values. * * @see SignatureSimilarity * @see ../../math/fuzzy/FuzzyMatrix * * @version Last modified on Sat Dec 07 19:07:01 2019 by hak * @author Hassan Aït-Kaci * @copyright © by the author */ public class ArgumentMappingMatrix extends SignatureSimilarity { /* ******************************************************************** */ /* FIELDS */ /* ******************************************************************** */ /** * The field mappings is an array of ArgumentPositionMapping * objects. It has a size equal to the size of degrees, * the DoubleArrayList inherited from FuzzyMatrix * and which is the set of degrees in the matrix of fuzzy similarity * values data after it has been closed into a similarity * from a set of declared similar pairs. Each mapping in * mappings can be seen as a 4-tuple of the form * [f,g,α,pairs_f,g,α], where:

f and g are distinct similar Functors;
α is the fuzzy value of this similar pair, a double in (0,1];
pairs_f,g,α is a finite sequence of * pairs of argument positions such that 0 ≤ * pairs_f,g,α.size() ≤ * Math.min(f.arity(),g.arity());
for each pair of indices i and j such that if * 0 ≤ i ≤ j < * degrees.size(): *
- mappings[i] ⊆ mappings[j] (i.e., * the mappings are approximation-consistent); and,
- for any pair of functors f and g, then: * pairs_{f,g,degrees[i]} ⊆ * pairs_{f,g,degrees[j]}.
* *

// * // *

  //  *      0   1   2   3   4   5
  //  *     --- --- --- --- --- ---
  //  * 0 | 1.0 0.5 0.0 0.5 0.4 0.2
  //  * 1 | 0.5 1.0 0.0 0.5 0.4 0.0
  //  * 2 | 0.0 0.0 1.0 0.0 0.0 0.0
  //  * 3 | 0.5 0.5 0.0 1.0 0.4 1.2
  //  * 4 | 0.4 0.4 0.0 0.4 1.0 0.2
  //  * 5 | 0.2 0.2 0.0 0.2 0.2 1.0
  //  *

// * then its partition(0.4) array is: // *

  //  * 0: A
  //  * 1: A
  //  * 2: B
  //  * 3: A
  //  * 4: A
  //  * 5: C
  //  *

// * where A=[0,1,3,4], B=[2], and C=[5]. // */ // public IntArrayList[] partition (double cut) // { // int rank = rank(); // // The array of rank classes // IntArrayList[] classes = new IntArrayList[rank]; // // initialize all classes to singletons // for (int i=0; i < rank; i++) // { // classes[i] = new IntArrayList(); // classes[i].add(i); // } // // sweep through the upper right triangle and merge the partitions // // of equivalent pairs over or at the cut // for (int i=0; i < rank-1; i++) // // { // for (int j=i+1; j < rank; j++) // if (data[i][j] >= cut) // // merge the classes at indices i and j and sets all related elements classes // merge(classes,i,j); // return classes; // } // /** // * This merges the classes classes[i] and classes[j] // * into a new class keeping it sorted in increasing order, and sets // * classes[k] to be this new merged class for all indices // * k in this class. // */ // private void merge (IntArrayList[] classes, int i, int j) // { // IntArrayList c1 = classes[i]; // IntArrayList c2 = classes[j]; // if (c1 != c2) // otherwise this would keep going // if (c2.size() < c1.size()) // { // for (int k=0; k < c2.size(); k++) // insertIndex(c2.get(k),c1); // // update all appropriate classes to the merged class // for (int k=0; k < c1.size(); k++) // classes[c1.get(k)] = c1; // } // else // { // for (int k=0; k < c1.size(); k++) // insertIndex(c1.get(k),c2); // // update all appropriate classes to the merged class // for (int k=0; k < c2.size(); k++) // classes[c2.get(k)] = c2; // } // } // /** // * Adds index to orderedClass keeping it in // * increasing order. // */ // private void insertIndex (int index, IntArrayList orderedClass) // { // int size = orderedClass.size(); // int i = 0; // while (i < size && orderedClass.get(i) < index) // i++; // if (index != orderedClass.get(i)) // orderedClass.add(i,index); // } }