Modifier and Type | Interface and Description |
---|---|
interface |
MutableDFA<S,I> |
Modifier and Type | Class and Description |
---|---|
class |
AbstractDFA<S,I> |
class |
AbstractMutableDFA<S,I> |
Modifier and Type | Method and Description |
---|---|
static <S,I> boolean |
AbstractDFA.accepts(DFA<S,I> $this,
Iterable<? extends I> input) |
Modifier and Type | Class and Description |
---|---|
class |
FastDFA<I> |
Modifier and Type | Class and Description |
---|---|
class |
CompactDFA<I> |
Modifier and Type | Class and Description |
---|---|
class |
BricsDFA
Adapter class for wrapping a Brics automaton as a
DFA . |
Modifier and Type | Method and Description |
---|---|
Word<I> |
AbstractIncrementalDFADAGBuilder.findSeparatingWord(DFA<?,I> target,
Collection<? extends I> inputs,
boolean omitUndefined) |
Modifier and Type | Method and Description |
---|---|
protected <S> Word<I> |
IncrementalPCDFATreeBuilder.doFindSeparatingWord(DFA<S,I> target,
Collection<? extends I> inputs,
boolean omitUndefined) |
protected <S> Word<I> |
IncrementalDFATreeBuilder.doFindSeparatingWord(DFA<S,I> target,
Collection<? extends I> inputs,
boolean omitUndefined) |
Word<I> |
IncrementalDFATreeBuilder.findSeparatingWord(DFA<?,I> target,
Collection<? extends I> inputs,
boolean omitUndefined) |
Modifier and Type | Method and Description |
---|---|
static <I> CompactDFA<I> |
DFAs.and(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the conjunction ("and") of two DFA, and returns the result as a new DFA.
|
static <I> CompactDFA<I> |
DFAs.and(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the conjunction ("and") of two DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.and(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the conjunction ("and") of two DFA, and stores the result in a given mutable DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.and(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the conjunction ("and") of two DFA, and stores the result in a given mutable DFA.
|
static <I> CompactDFA<I> |
DFAs.combine(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner)
Most general way of combining two DFAs.
|
static <I> CompactDFA<I> |
DFAs.combine(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner)
Most general way of combining two DFAs.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.combine(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner)
Most general way of combining two DFAs.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.combine(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner)
Most general way of combining two DFAs.
|
static <I> CompactDFA<I> |
DFAs.complement(DFA<?,I> dfa,
Alphabet<I> inputAlphabet)
Calculates the complement (negation) of a DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.complement(DFA<?,I> dfa,
Collection<? extends I> inputs,
A out)
Calculates the complement (negation) of a DFA, and stores the result in a given mutable DFA.
|
static <I> CompactDFA<I> |
DFAs.complete(DFA<?,I> dfa,
Alphabet<I> inputs) |
static <I,S,A extends MutableDFA<S,I>> |
DFAs.complete(DFA<?,I> dfa,
Collection<? extends I> inputs,
A out) |
static <I> CompactDFA<I> |
DFAs.equiv(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the equivalence ("<=>") of two DFA, and returns the result as a new DFA.
|
static <I> CompactDFA<I> |
DFAs.equiv(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the equivalence ("<=>") of two DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.equiv(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the equivalence ("<=>") of two DFA, and stores the result in a given mutable DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.equiv(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the equivalence ("<=>") of two DFA, and stores the result in a given mutable DFA.
|
static <I> CompactDFA<I> |
DFAs.impl(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the implication ("=>") of two DFA, and returns the result as a new DFA.
|
static <I> CompactDFA<I> |
DFAs.impl(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the implication ("=>") of two DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.impl(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the implication ("=>") of two DFA, and stores the result in a given mutable DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.impl(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the implication ("=>") of two DFA, and stores the result in a given mutable DFA.
|
static <I> CompactDFA<I> |
DFAs.or(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the disjunction ("or") of two DFA, and returns the result as a new DFA.
|
static <I> CompactDFA<I> |
DFAs.or(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the disjunction ("or") of two DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.or(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the disjunction ("or") of two DFA, and stores the result in a given mutable DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.or(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the disjunction ("or") of two DFA, and stores the result in a given mutable DFA.
|
static <I> CompactDFA<I> |
DFAs.xor(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the exclusive-or ("xor") of two DFA, and returns the result as a new DFA.
|
static <I> CompactDFA<I> |
DFAs.xor(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Alphabet<I> inputAlphabet)
Calculates the exclusive-or ("xor") of two DFA, and returns the result as a new DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.xor(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the exclusive-or ("xor") of two DFA, and stores the result in a given mutable DFA.
|
static <I,S,A extends MutableDFA<S,I>> |
DFAs.xor(DFA<?,I> dfa1,
DFA<?,I> dfa2,
Collection<? extends I> inputs,
A out)
Calculates the exclusive-or ("xor") of two DFA, and stores the result in a given mutable DFA.
|
Copyright © 2015. All rights reserved.