Closer (Universal Algebra Calculator API)

java.lang.Object
- org.uacalc.alg.Closer

```
public class Closer
extends java.lang.Object
```
A class for finding the closure with configurations for several options and fields to hold side results. It only deals with BigProduct's now. We might call it BigProductCloser and have Closer as an interface.

Author:

ralph

Field Summary

Fields
Modifier and Type Field and Description

static boolean doParallel
Closure of elems under the operations.

Fields
Modifier and Type	Field and Description
`static boolean`	`doParallel` Closure of `elems` under the operations.

Constructor Summary

Constructors
Constructor and Description
`Closer(BigProductAlgebra alg, java.util.List<IntArray> gens)`
`Closer(BigProductAlgebra alg, java.util.List<IntArray> gens, boolean makeTermMap)`
`Closer(BigProductAlgebra alg, java.util.List<IntArray> gens, java.util.Map<IntArray,Term> termMap)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allElementsFound()`
`java.util.List<IntArray>`	`close()`
`long`	`countFuncApplications(int size0, int size1)`
`void`	`doOneStagePartialClosure(java.util.concurrent.ConcurrentHashMap<IntArray,Term> map, int indexInCPUs, int numOfOps, int closedMark, int currentMark, boolean reportNotNull, java.util.List<int[]> rawList, CloserTiming timing)` Note this assumes termMap is not null !!!!!!!!
`java.util.List<IntArray>`	`getAnswer()`
`int[][]`	`getBlocks()` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`int`	`getCongruenceConstraintElemIndex()`
`Partition`	`getCongruenceForCongruenceConstraint()`
`java.util.List<IntArray>`	`getElementsToFind()`
`IntArray`	`getElementToFind()`
`Equation`	`getFailingEquation()`
`java.util.List<IntArray>`	`getGenerators()` Returns a shallow copy of the list of generators used by `this Closer` to generate a subuniverse.
`java.util.Map<IntArray,java.lang.Integer>`	`getHomomorphism()`
`SmallAlgebra`	`getImageAlgebra()`
`int`	`getIndexForCongruenceConstraint()`
`int`	`getIndexForConstraintSet()` Get the index for the SetConstraint.
`int`	`getmaxSize()`
`java.util.Set<java.lang.Integer>`	`getSetConstraint()` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`java.util.Map<IntArray,Term>`	`getTermMap()` Returns a `Map` assigning to each tuple in the generated subuniverse a term over the signature of the underlying algebra whose term operation can be applied to the generators to obtain the tuple.
`java.util.Map<Operation,Term>`	`getTermMapForOperations()`
`int[][]`	`getValues()` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`boolean`	`isSuppressOutput()`
`void`	`setBlocks(int[][] blocks)` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`void`	`setCongruenceConstraintElemIndex(int congruenceConstraintElemIndex)`
`void`	`setCongruenceForCongruenceConstraint(Partition alpha)`
`void`	`setConstraintSet(java.util.Set<java.lang.Integer> set)` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`void`	`setElementsToFind(java.util.List<IntArray> e, java.util.List<IntArray> gens)` This takes `e` and deletes duplicates, maintaining the order, before setting `eltsToFind`.
`void`	`setElementToFind(IntArray e)`
`void`	`setGenerators(java.util.List<IntArray> gens)` This sets `generators` to `gens` without any duplicates.
`void`	`setHomomorphism(int[] algGens)`
`void`	`setHomomorphism(java.util.Map<IntArray,java.lang.Integer> homomorphism)`
`void`	`setImageAlgebra(SmallAlgebra alg)`
`void`	`setIndexForCongruenceConstraint(int indexForCongruenceConstraint)`
`void`	`setIndexForConstraintSet(int k)` Set the index for the SetConstraint.
`void`	`setMaxSize(int k)`
`void`	`setOperations(java.util.List<Operation> opers)`
`void`	`setProgressReport(ProgressReport report)`
`void`	`setRootAlgebra(SmallAlgebra alg)` Sets the root of a power algebra, if the closing computes a subpower.
`void`	`setSuppressOutput(boolean suppressOutput)` Setting this to true will suppress the output about the pass.
`void`	`setTermMap(java.util.Map<IntArray,Term> termMap)` Initialises the `Map` that will be used to assign to each tuple in the generated subuniverse a term over the signature of the underlying algebra whose term operation can be applied to the generators to obtain the tuple.
`void`	`setupCongruenceConstraint(Partition alpha, int index, int elemIndex)`
`void`	`setValues(int[][] values)` blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
`java.util.List<IntArray>`	`sgClose()`
`java.util.List<IntArray>`	`sgClose(java.util.List<IntArray> elems, int closedMark, java.util.Map<IntArray,Term> termMap)`
`java.util.List<IntArray>`	`sgCloseParallel_Old(java.util.List<IntArray> elems, int closedMark, java.util.Map<IntArray,Term> termMap)` Closure of `elems` under the operations.
`java.util.List<IntArray>`	`sgCloseParallel(java.util.List<IntArray> elems, int closedMark, java.util.concurrent.ConcurrentMap<IntArray,Term> termMap)`
`java.util.List<IntArray>`	`sgClosePower()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - doParallel
```
public static boolean doParallel
```
    Closure of elems under the operations. (Worry about nullary ops later.)
- Constructor Detail
  - Closer
```
public Closer(BigProductAlgebra alg,
              java.util.List<IntArray> gens)
```
  - Closer
```
public Closer(BigProductAlgebra alg,
              java.util.List<IntArray> gens,
              java.util.Map<IntArray,Term> termMap)
```
  - Closer
```
public Closer(BigProductAlgebra alg,
              java.util.List<IntArray> gens,
              boolean makeTermMap)
```
- Method Detail
  - getAnswer
```
public java.util.List<IntArray> getAnswer()
```
  - getFailingEquation
```
public Equation getFailingEquation()
```
  - getTermMapForOperations
```
public java.util.Map<Operation,Term> getTermMapForOperations()
```
  - setRootAlgebra
```
public void setRootAlgebra(SmallAlgebra alg)
```
    Sets the root of a power algebra, if the closing computes a subpower. If the underlying BigProductAlgebra is a power, then this method can be used to set the field of the closer referencing the root underlying the power.
    
    Parameters:
    
    alg - a SmallAlgebra such that its power is the BigProductAlgebra determining the closure to be generated by the Closer.
  - setOperations
```
public void setOperations(java.util.List<Operation> opers)
```
  - getGenerators
```
public java.util.List<IntArray> getGenerators()
```
    Returns a shallow copy of the list of generators used by this Closer to generate a subuniverse. The returned list is part of the Closer object, so any modification applied to it modifies the Closer.
    
    Returns:
    
    a List of IntArrays representing the generating set whose closure is to be computed
  - setGenerators
```
public void setGenerators(java.util.List<IntArray> gens)
```
    This sets generators to gens without any duplicates. Initializes the internal field of the Closer to contain the generators from gens in the order they occur there, ignoring possible repetitions of tuples in gens.
    
    Parameters:
    
    gens - a List of tuples (IntArrays) from which a subuniverse should be generated
  - getTermMap
```
public java.util.Map<IntArray,Term> getTermMap()
```
    Returns a Map assigning to each tuple in the generated subuniverse a term over the signature of the underlying algebra whose term operation can be applied to the generators to obtain the tuple. Initially this is only a map, mapping generators to variables. After the closing it is a map between the elements of the generated subuniverse and the generating terms.
    Only a shallow copy is returned, that is, the returned Map is part of the Closer.
    
    Returns:
    
    a Map mapping IntArrays to Terms
  - setTermMap
```
public void setTermMap(java.util.Map<IntArray,Term> termMap)
```
    Initialises the Map that will be used to assign to each tuple in the generated subuniverse a term over the signature of the underlying algebra whose term operation can be applied to the generators to obtain the tuple. Only a shallow copy of the external Map is made, that is the Map becomes part of the Closer.
    
    Parameters:
    
    termMap - a Map mapping IntArrays to Terms, it should map the generators to variables, to be reasonable, or it should be null.
  - getImageAlgebra
```
public SmallAlgebra getImageAlgebra()
```
  - setImageAlgebra
```
public void setImageAlgebra(SmallAlgebra alg)
```
  - getHomomorphism
```
public java.util.Map<IntArray,java.lang.Integer> getHomomorphism()
```
  - setHomomorphism
```
public void setHomomorphism(java.util.Map<IntArray,java.lang.Integer> homomorphism)
```
  - setHomomorphism
```
public void setHomomorphism(int[] algGens)
```
  - getElementToFind
```
public IntArray getElementToFind()
```
  - setElementToFind
```
public void setElementToFind(IntArray e)
```
  - getElementsToFind
```
public java.util.List<IntArray> getElementsToFind()
```
  - setElementsToFind
```
public void setElementsToFind(java.util.List<IntArray> e,
                              java.util.List<IntArray> gens)
```
    This takes e and deletes duplicates, maintaining the order, before setting eltsToFind.
    
    Parameters:
    
    e -
    
    gens -
  - allElementsFound
```
public boolean allElementsFound()
```
  - getBlocks
```
public int[][] getBlocks()
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
    
    Returns:
  - setBlocks
```
public void setBlocks(int[][] blocks)
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
  - getValues
```
public int[][] getValues()
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
    
    Returns:
  - setValues
```
public void setValues(int[][] values)
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
  - getSetConstraint
```
public java.util.Set<java.lang.Integer> getSetConstraint()
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
    
    Returns:
  - setConstraintSet
```
public void setConstraintSet(java.util.Set<java.lang.Integer> set)
```
    blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
  - getIndexForConstraintSet
```
public int getIndexForConstraintSet()
```
    Get the index for the SetConstraint. blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
    
    Returns:
  - setIndexForConstraintSet
```
public void setIndexForConstraintSet(int k)
```
    Set the index for the SetConstraint. blocks, values and setConstraints are specified in IntArray and are used to restrict the element we are looking for.
  - getIndexForCongruenceConstraint
```
public int getIndexForCongruenceConstraint()
```
    Returns:
    
    the indexForCongruenceConstraint
  - setIndexForCongruenceConstraint
```
public void setIndexForCongruenceConstraint(int indexForCongruenceConstraint)
```
    Parameters:
    
    indexForCongruenceConstraint - the indexForCongruenceConstraint to set
  - getCongruenceConstraintElemIndex
```
public int getCongruenceConstraintElemIndex()
```
    Returns:
    
    the congruenceConstraintElemIndex
  - setCongruenceConstraintElemIndex
```
public void setCongruenceConstraintElemIndex(int congruenceConstraintElemIndex)
```
    Parameters:
    
    congruenceConstraintElemIndex - the congruenceConstraintElemIndex to set
  - getCongruenceForCongruenceConstraint
```
public Partition getCongruenceForCongruenceConstraint()
```
  - setCongruenceForCongruenceConstraint
```
public void setCongruenceForCongruenceConstraint(Partition alpha)
```
    Parameters:
    
    alpha - the congruenceConstraintAlpha to set
  - setupCongruenceConstraint
```
public void setupCongruenceConstraint(Partition alpha,
                                      int index,
                                      int elemIndex)
```
  - getmaxSize
```
public int getmaxSize()
```
  - setMaxSize
```
public void setMaxSize(int k)
```
  - setProgressReport
```
public void setProgressReport(ProgressReport report)
```
  - close
```
public java.util.List<IntArray> close()
```
  - sgClose
```
public java.util.List<IntArray> sgClose()
```
  - sgClose
```
public java.util.List<IntArray> sgClose(java.util.List<IntArray> elems,
                                        int closedMark,
                                        java.util.Map<IntArray,Term> termMap)
```
  - sgCloseParallel
```
public java.util.List<IntArray> sgCloseParallel(java.util.List<IntArray> elems,
                                                int closedMark,
                                                java.util.concurrent.ConcurrentMap<IntArray,Term> termMap)
```
  - sgCloseParallel_Old
```
public java.util.List<IntArray> sgCloseParallel_Old(java.util.List<IntArray> elems,
                                                    int closedMark,
                                                    java.util.Map<IntArray,Term> termMap)
```
    Closure of elems under the operations. (Worry about nullary ops later.)
    
    Parameters:
    
    elems - a List of IntArray's
    
    termMap - a Map from the element to the corresponding term used to generated it. The generators should be already in the Map. In other words the termMap should have the same number of entries as elems.
    
    Returns:
    
    a List of IntArray's.
  - sgClosePower
```
public java.util.List<IntArray> sgClosePower()
```
  - countFuncApplications
```
public long countFuncApplications(int size0,
                                  int size1)
```
  - doOneStagePartialClosure
```
public void doOneStagePartialClosure(java.util.concurrent.ConcurrentHashMap<IntArray,Term> map,
                                     int indexInCPUs,
                                     int numOfOps,
                                     int closedMark,
                                     int currentMark,
                                     boolean reportNotNull,
                                     java.util.List<int[]> rawList,
                                     CloserTiming timing)
```
    Note this assumes termMap is not null !!!!!!!!
    
    Parameters:
    
    map -
    
    indexInCPUs -
    
    numOfOps -
    
    closedMark -
    
    currentMark -
    
    reportNotNull -
    
    rawList -
    
    timing -
  - isSuppressOutput
```
public boolean isSuppressOutput()
```
  - setSuppressOutput
```
public void setSuppressOutput(boolean suppressOutput)
```
    Setting this to true will suppress the output about the pass. Useful when calling closing on many small cases.
    
    Parameters:
    
    suppressOutput -

Class Closer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

doParallel

Constructor Detail

Closer

Closer

Closer

Method Detail

getAnswer

getFailingEquation

getTermMapForOperations

setRootAlgebra

setOperations

getGenerators

setGenerators

getTermMap

setTermMap

getImageAlgebra

setImageAlgebra

getHomomorphism

setHomomorphism

setHomomorphism

getElementToFind

setElementToFind

getElementsToFind

setElementsToFind

allElementsFound

getBlocks

setBlocks

getValues

setValues

getSetConstraint

setConstraintSet

getIndexForConstraintSet

setIndexForConstraintSet

getIndexForCongruenceConstraint

setIndexForCongruenceConstraint

getCongruenceConstraintElemIndex

setCongruenceConstraintElemIndex

getCongruenceForCongruenceConstraint

setCongruenceForCongruenceConstraint

setupCongruenceConstraint

getmaxSize

setMaxSize

setProgressReport

close

sgClose

sgClose

sgCloseParallel

sgCloseParallel_Old

sgClosePower

countFuncApplications

doOneStagePartialClosure

isSuppressOutput

setSuppressOutput