Operations (Lucene 4.10.2 API)

java.lang.Object
- org.apache.lucene.util.automaton.Operations

```
public final class Operations
extends Object
```
Automata operations.

WARNING: This API is experimental and might change in incompatible ways in the next release.

Method Summary

Methods
Modifier and Type	Method and Description
`static Automaton`	`complement(Automaton a)` Returns a (deterministic) automaton that accepts the complement of the language of the given automaton.
`static Automaton`	`concatenate(Automaton a1, Automaton a2)` Returns an automaton that accepts the concatenation of the languages of the given automata.
`static Automaton`	`concatenate(List<Automaton> l)` Returns an automaton that accepts the concatenation of the languages of the given automata.
`static Automaton`	`determinize(Automaton a)` Determinizes the given automaton.
`static String`	`getCommonPrefix(Automaton a)` Returns the longest string that is a prefix of all accepted strings and visits each state at most once.
`static BytesRef`	`getCommonPrefixBytesRef(Automaton a)` Returns the longest BytesRef that is a prefix of all accepted strings and visits each state at most once.
`static BytesRef`	`getCommonSuffixBytesRef(Automaton a)` Returns the longest BytesRef that is a suffix of all accepted strings.
`static Set<IntsRef>`	`getFiniteStrings(Automaton a, int limit)` Returns the set of accepted strings, up to at most `limit` strings.
`static boolean`	`hasDeadStates(Automaton a)` Returns true if this automaton has any states that cannot be reached from the initial state or cannot reach an accept state.
`static boolean`	`hasDeadStatesFromInitial(Automaton a)` Returns true if there are dead states reachable from an initial state.
`static boolean`	`hasDeadStatesToAccept(Automaton a)` Returns true if there are dead states that reach an accept state.
`static Automaton`	`intersection(Automaton a1, Automaton a2)` Returns an automaton that accepts the intersection of the languages of the given automata.
`static boolean`	`isEmpty(Automaton a)` Returns true if the given automaton accepts no strings.
`static boolean`	`isFinite(Automaton a)` Returns true if the language of this automaton is finite.
`static boolean`	`isTotal(Automaton a)` Returns true if the given automaton accepts all strings.
`static Automaton`	`minus(Automaton a1, Automaton a2)` Returns a (deterministic) automaton that accepts the intersection of the language of `a1` and the complement of the language of `a2`.
`static Automaton`	`optional(Automaton a)` Returns an automaton that accepts the union of the empty string and the language of the given automaton.
`static Automaton`	`removeDeadStates(Automaton a)` Removes transitions to dead states (a state is "dead" if it is not reachable from the initial state or no accept state is reachable from it.)
`static Automaton`	`repeat(Automaton a)` Returns an automaton that accepts the Kleene star (zero or more concatenated repetitions) of the language of the given automaton.
`static Automaton`	`repeat(Automaton a, int min)` Returns an automaton that accepts `min` or more concatenated repetitions of the language of the given automaton.
`static Automaton`	`repeat(Automaton a, int min, int max)` Returns an automaton that accepts between `min` and `max` (including both) concatenated repetitions of the language of the given automaton.
`static Automaton`	`reverse(Automaton a)` Returns an automaton accepting the reverse language.
`static boolean`	`run(Automaton a, IntsRef s)` Returns true if the given string (expressed as unicode codepoints) is accepted by the automaton.
`static boolean`	`run(Automaton a, String s)` Returns true if the given string is accepted by the automaton.
`static boolean`	`sameLanguage(Automaton a1, Automaton a2)` Returns true if these two automata accept exactly the same language.
`static boolean`	`subsetOf(Automaton a1, Automaton a2)` Returns true if the language of `a1` is a subset of the language of `a2`.
`static Automaton`	`union(Automaton a1, Automaton a2)` Returns an automaton that accepts the union of the languages of the given automata.
`static Automaton`	`union(Collection<Automaton> l)` Returns an automaton that accepts the union of the languages of the given automata.

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

- Method Detail
  - concatenate
```
public static Automaton concatenate(Automaton a1,
                    Automaton a2)
```
    Returns an automaton that accepts the concatenation of the languages of the given automata.
    Complexity: linear in total number of states.
  - concatenate
```
public static Automaton concatenate(List<Automaton> l)
```
    Returns an automaton that accepts the concatenation of the languages of the given automata.
    Complexity: linear in total number of states.
  - optional
```
public static Automaton optional(Automaton a)
```
    Returns an automaton that accepts the union of the empty string and the language of the given automaton.
    Complexity: linear in number of states.
  - repeat
```
public static Automaton repeat(Automaton a)
```
    Returns an automaton that accepts the Kleene star (zero or more concatenated repetitions) of the language of the given automaton. Never modifies the input automaton language.
    Complexity: linear in number of states.
  - repeat
```
public static Automaton repeat(Automaton a,
               int min)
```
    Returns an automaton that accepts min or more concatenated repetitions of the language of the given automaton.
    Complexity: linear in number of states and in min.
  - repeat
```
public static Automaton repeat(Automaton a,
               int min,
               int max)
```
    Returns an automaton that accepts between min and max (including both) concatenated repetitions of the language of the given automaton.
    Complexity: linear in number of states and in min and max.
  - complement
```
public static Automaton complement(Automaton a)
```
    Returns a (deterministic) automaton that accepts the complement of the language of the given automaton.
    Complexity: linear in number of states (if already deterministic).
  - minus
```
public static Automaton minus(Automaton a1,
              Automaton a2)
```
    Returns a (deterministic) automaton that accepts the intersection of the language of a1 and the complement of the language of a2. As a side-effect, the automata may be determinized, if not already deterministic.
    Complexity: quadratic in number of states (if already deterministic).
  - intersection
```
public static Automaton intersection(Automaton a1,
                     Automaton a2)
```
    Returns an automaton that accepts the intersection of the languages of the given automata. Never modifies the input automata languages.
    Complexity: quadratic in number of states.
  - sameLanguage
```
public static boolean sameLanguage(Automaton a1,
                   Automaton a2)
```
    Returns true if these two automata accept exactly the same language. This is a costly computation! Note also that a1 and a2 will be determinized as a side effect. Both automata must be determinized and have no dead states!
  - hasDeadStates
```
public static boolean hasDeadStates(Automaton a)
```
    Returns true if this automaton has any states that cannot be reached from the initial state or cannot reach an accept state. Cost is O(numTransitions+numStates).
  - hasDeadStatesFromInitial
```
public static boolean hasDeadStatesFromInitial(Automaton a)
```
    Returns true if there are dead states reachable from an initial state.
  - hasDeadStatesToAccept
```
public static boolean hasDeadStatesToAccept(Automaton a)
```
    Returns true if there are dead states that reach an accept state.
  - subsetOf
```
public static boolean subsetOf(Automaton a1,
               Automaton a2)
```
    Returns true if the language of a1 is a subset of the language of a2. Both automata must be determinized and must have no dead states.
    Complexity: quadratic in number of states.
  - union
```
public static Automaton union(Automaton a1,
              Automaton a2)
```
    Returns an automaton that accepts the union of the languages of the given automata.
    Complexity: linear in number of states.
  - union
```
public static Automaton union(Collection<Automaton> l)
```
    Returns an automaton that accepts the union of the languages of the given automata.
    Complexity: linear in number of states.
  - determinize
```
public static Automaton determinize(Automaton a)
```
    Determinizes the given automaton.
    Worst case complexity: exponential in number of states.
  - isEmpty
```
public static boolean isEmpty(Automaton a)
```
    Returns true if the given automaton accepts no strings.
  - isTotal
```
public static boolean isTotal(Automaton a)
```
    Returns true if the given automaton accepts all strings. The automaton must be minimized.
  - run
```
public static boolean run(Automaton a,
          String s)
```
    Returns true if the given string is accepted by the automaton. The input must be deterministic.
    Complexity: linear in the length of the string.
    Note: for full performance, use the RunAutomaton class.
  - run
```
public static boolean run(Automaton a,
          IntsRef s)
```
    Returns true if the given string (expressed as unicode codepoints) is accepted by the automaton. The input must be deterministic.
    Complexity: linear in the length of the string.
    Note: for full performance, use the RunAutomaton class.
  - removeDeadStates
```
public static Automaton removeDeadStates(Automaton a)
```
    Removes transitions to dead states (a state is "dead" if it is not reachable from the initial state or no accept state is reachable from it.)
  - isFinite
```
public static boolean isFinite(Automaton a)
```
    Returns true if the language of this automaton is finite. The automaton must not have any dead states.
  - getCommonPrefix
```
public static String getCommonPrefix(Automaton a)
```
    Returns the longest string that is a prefix of all accepted strings and visits each state at most once. The automaton must be deterministic.
    
    Returns:
    common prefix
  - getCommonPrefixBytesRef
```
public static BytesRef getCommonPrefixBytesRef(Automaton a)
```
    Returns the longest BytesRef that is a prefix of all accepted strings and visits each state at most once. The automaton must be deterministic.
    
    Returns:
    common prefix
  - getCommonSuffixBytesRef
```
public static BytesRef getCommonSuffixBytesRef(Automaton a)
```
    Returns the longest BytesRef that is a suffix of all accepted strings. Worst case complexity: exponential in number of states (this calls determinize).
    
    Returns:
    common suffix
  - reverse
```
public static Automaton reverse(Automaton a)
```
    Returns an automaton accepting the reverse language.
  - getFiniteStrings
```
public static Set<IntsRef> getFiniteStrings(Automaton a,
                            int limit)
```
    Returns the set of accepted strings, up to at most limit strings. If more than limit strings are accepted, the first limit strings found are returned. If limit == -1, then the limit is infinite. If the Automaton has cycles then this method might throw IllegalArgumentException but that is not guaranteed when the limit is set.

Class Operations

Method Summary

Methods inherited from class java.lang.Object

Method Detail

concatenate

concatenate

optional

repeat

repeat

repeat

complement

minus

intersection

sameLanguage

hasDeadStates

hasDeadStatesFromInitial

hasDeadStatesToAccept

subsetOf

union

union

determinize

isEmpty

isTotal

run

run

removeDeadStates

isFinite

getCommonPrefix

getCommonPrefixBytesRef

getCommonSuffixBytesRef

reverse

getFiniteStrings