net.automatalib.util.ts.copy

Class TSCopy

java.lang.Object

net.automatalib.util.ts.copy.TSCopy

public final class TSCopy
extends Object

Method Summary

Modifier and Type	Method and Description
static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I1,T1,? extends SP,? extends TP> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP,? super TP> out, Function<? super I1,? extends I2> inputsMapping) Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties.
static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I1,T1,? extends SP,? extends TP> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP,? super TP> out, Function<? super I1,? extends I2> inputsMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter) Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties.
static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I1,T1,? extends SP1,? extends TP1> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform) Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.
static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I1,T1,? extends SP1,? extends TP1> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter) Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.
static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I,T1,? extends SP,? extends TP> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP,? super TP> out) Copies a UniversalAutomaton with compatible input alphabets and properties.
static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I,T1,? extends SP,? extends TP> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP,? super TP> out, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter) Copies a UniversalAutomaton with compatible input alphabets and properties.
static <S1,I,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I,T1,? extends SP1,? extends TP1> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform) Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties.
static <S1,I,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	copy(TSTraversalMethod method, UniversalTransitionSystem<S1,? super I,T1,? extends SP1,? extends TP1> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter) Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties.
static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	rawCopy(TSTraversalMethod method, TransitionSystem<S1,? super I1,T1> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping) Copies an Automaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.
static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>	rawCopy(TSTraversalMethod method, TransitionSystem<S1,? super I1,T1> in, int limit, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter) Copies an TransitionSystem to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.
static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2>	rawCopy(TSTraversalMethod method, TransitionSystem<S1,? super I,T1> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,SP2,TP2> out, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping) Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties.
static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2>	rawCopy(TSTraversalMethod method, TransitionSystem<S1,? super I,T1> in, int limit, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,SP2,TP2> out, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter) Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

rawCopy

public static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(TSTraversalMethod method,
                                                                 TransitionSystem<S1,? super I1,T1> in,
                                                                 int limit,
                                                                 Collection<? extends I1> inputs,
                                                                 MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                 Function<? super I1,? extends I2> inputsMapping,
                                                                 Function<? super S1,? extends SP2> spMapping,
                                                                 Function<? super T1,? extends TP2> tpMapping)

Copies an Automaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties. State and transitions will not be filtered.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - the transformation for input symbols

spMapping - the function for obtaining state properties

tpMapping - the function for obtaining transition properties

Returns:

a mapping from old to new states

rawCopy

public static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(TSTraversalMethod method,
                                                                 TransitionSystem<S1,? super I1,T1> in,
                                                                 int limit,
                                                                 Collection<? extends I1> inputs,
                                                                 MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                 Function<? super I1,? extends I2> inputsMapping,
                                                                 Function<? super S1,? extends SP2> spMapping,
                                                                 Function<? super T1,? extends TP2> tpMapping,
                                                                 Predicate<? super S1> stateFilter,
                                                                 TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies an TransitionSystem to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - the transformation for input symbols

spMapping - the function for obtaining state properties

tpMapping - the function for obtaining transition properties

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states

rawCopy

public static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(TSTraversalMethod method,
                                                             TransitionSystem<S1,? super I,T1> in,
                                                             int limit,
                                                             Collection<? extends I> inputs,
                                                             MutableAutomaton<S2,I,T2,SP2,TP2> out,
                                                             Function<? super S1,? extends SP2> spMapping,
                                                             Function<? super T1,? extends TP2> tpMapping)

Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties. States and transitions will not be filtered.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

spMapping - the function for obtaining state properties

tpMapping - the function for obtaining transition properties

Returns:

a mapping from old to new states

rawCopy

public static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(TSTraversalMethod method,
                                                             TransitionSystem<S1,? super I,T1> in,
                                                             int limit,
                                                             Collection<? extends I> inputs,
                                                             MutableAutomaton<S2,I,T2,SP2,TP2> out,
                                                             Function<? super S1,? extends SP2> spMapping,
                                                             Function<? super T1,? extends TP2> tpMapping,
                                                             Predicate<? super S1> stateFilter,
                                                             TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

spMapping - the function for obtaining state properties

tpMapping - the function for obtaining transition properties

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states

copy

public static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                                      UniversalTransitionSystem<S1,? super I1,T1,? extends SP1,? extends TP1> in,
                                                                      int limit,
                                                                      Collection<? extends I1> inputs,
                                                                      MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                      Function<? super I1,? extends I2> inputsMapping,
                                                                      Function<? super SP1,? extends SP2> spTransform,
                                                                      Function<? super TP1,? extends TP2> tpTransform)

Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties. States and transitions will not be filtered

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - the transformation for input symbols

spTransform - the transformation for state properties

tpTransform - the transformation for transition properties

Returns:

a mapping from old to new states

copy

public static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                                      UniversalTransitionSystem<S1,? super I1,T1,? extends SP1,? extends TP1> in,
                                                                      int limit,
                                                                      Collection<? extends I1> inputs,
                                                                      MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                      Function<? super I1,? extends I2> inputsMapping,
                                                                      Function<? super SP1,? extends SP2> spTransform,
                                                                      Function<? super TP1,? extends TP2> tpTransform,
                                                                      Predicate<? super S1> stateFilter,
                                                                      TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - the transformation for input symbols

spTransform - the transformation for state properties

tpTransform - the transformation for transition properties

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states

copy

public static <S1,I,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                                     UniversalTransitionSystem<S1,? super I,T1,? extends SP1,? extends TP1> in,
                                                                     int limit,
                                                                     Collection<? extends I> inputs,
                                                                     MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out,
                                                                     Function<? super SP1,? extends SP2> spTransform,
                                                                     Function<? super TP1,? extends TP2> tpTransform)

Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties. States and transitions will not be filtered.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

spTransform - the transformation for state properties

tpTransform - the transformation for transition properties

Returns:

a mapping from old to new states

copy

public static <S1,I,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                                     UniversalTransitionSystem<S1,? super I,T1,? extends SP1,? extends TP1> in,
                                                                     int limit,
                                                                     Collection<? extends I> inputs,
                                                                     MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out,
                                                                     Function<? super SP1,? extends SP2> spTransform,
                                                                     Function<? super TP1,? extends TP2> tpTransform,
                                                                     Predicate<? super S1> stateFilter,
                                                                     TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

spTransform - the transformation for state properties

tpTransform - the transformation for transition properties

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states

copy

public static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                            UniversalTransitionSystem<S1,? super I1,T1,? extends SP,? extends TP> in,
                                                            int limit,
                                                            Collection<? extends I1> inputs,
                                                            MutableAutomaton<S2,I2,T2,? super SP,? super TP> out,
                                                            Function<? super I1,? extends I2> inputsMapping)

Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties. States and transitions will not be filtered

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - a mapping from inputs in the input automaton to inputs in the output automaton

Returns:

a mapping from old to new states

copy

public static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                            UniversalTransitionSystem<S1,? super I1,T1,? extends SP,? extends TP> in,
                                                            int limit,
                                                            Collection<? extends I1> inputs,
                                                            MutableAutomaton<S2,I2,T2,? super SP,? super TP> out,
                                                            Function<? super I1,? extends I2> inputsMapping,
                                                            Predicate<? super S1> stateFilter,
                                                            TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

inputsMapping - the transformation for input symbols

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states

copy

public static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                        UniversalTransitionSystem<S1,? super I,T1,? extends SP,? extends TP> in,
                                                        int limit,
                                                        Collection<? extends I> inputs,
                                                        MutableAutomaton<S2,I,T2,? super SP,? super TP> out)

Copies a UniversalAutomaton with compatible input alphabets and properties. States and transitions will not be filtered.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

Returns:

a mapping from old to new states.

copy

public static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2> copy(TSTraversalMethod method,
                                                        UniversalTransitionSystem<S1,? super I,T1,? extends SP,? extends TP> in,
                                                        int limit,
                                                        Collection<? extends I> inputs,
                                                        MutableAutomaton<S2,I,T2,? super SP,? super TP> out,
                                                        Predicate<? super S1> stateFilter,
                                                        TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies a UniversalAutomaton with compatible input alphabets and properties.

Parameters:

method - the traversal method to use

in - the input transition system

limit - the traversal limit, a value less than 0 means no limit

inputs - the inputs to consider

out - the output automaton

stateFilter - the filter predicate for states

transFilter - the filter predicate for transitions

Returns:

a mapping from old to new states