net.automatalib.util.ts.copy.TSCopy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of automata-util Show documentation
Show all versions of automata-util Show documentation
This artifact provides various common utility operations for analyzing and manipulating
automata and graphs, such as traversal, minimization and copying.
/* Copyright (C) 2014 TU Dortmund
* This file is part of AutomataLib, http://www.automatalib.net/.
*
* AutomataLib is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 3.0 as published by the Free Software Foundation.
*
* AutomataLib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AutomataLib; if not, see
* http://www.gnu.de/documents/lgpl.en.html.
*/
package net.automatalib.util.ts.copy;
import java.util.Collection;
import net.automatalib.automata.Automaton;
import net.automatalib.automata.MutableAutomaton;
import net.automatalib.automata.UniversalAutomaton;
import net.automatalib.commons.util.mappings.Mapping;
import net.automatalib.ts.TransitionPredicate;
import net.automatalib.ts.TransitionSystem;
import net.automatalib.ts.UniversalTransitionSystem;
import net.automatalib.util.automata.predicates.TransitionPredicates;
import net.automatalib.util.ts.TS;
import net.automatalib.util.ts.traversal.TSTraversalMethod;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
public class TSCopy {
/**
* Copies an {@link TransitionSystem} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and
* state and transition properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping the transformation for input symbols
* @param spMapping the function for obtaining state properties
* @param tpMapping the function for obtaining transition properties
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping rawCopy(TSTraversalMethod method,
TransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spMapping,
Function tpMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
if(spMapping == null) {
spMapping = Functions.constant(null);
}
if(tpMapping == null) {
tpMapping = Functions.constant(null);
}
if(stateFilter == null) {
stateFilter = Predicates.alwaysTrue();
}
if(transFilter == null) {
transFilter = TransitionPredicates.alwaysTrue();
}
TSCopyVisitor vis = new TSCopyVisitor<>(in, out, inputsMapping, spMapping, tpMapping, stateFilter, transFilter);
method.traverse(in, limit, inputs, vis);
return vis.getStateMapping();
}
/**
* Copies an {@link Automaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and
* state and transition properties. State and transitions will not be filtered.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping the transformation for input symbols
* @param spMapping the function for obtaining state properties
* @param tpMapping the function for obtaining transition properties
* @return a mapping from old to new states
*/
public static
Mapping rawCopy(TSTraversalMethod method,
TransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spMapping,
Function tpMapping) {
return rawCopy(method, in, limit, inputs, out, inputsMapping, spMapping, tpMapping, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
/**
* Copies an {@link Automaton} to a {@link MutableAutomaton} with a compatible input alphabet, but possibly heterogeneous state and
* transition properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param spMapping the function for obtaining state properties
* @param tpMapping the function for obtaining transition properties
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping rawCopy(TSTraversalMethod method,
TransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function spMapping,
Function tpMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
return rawCopy(method, in, limit, inputs, out, Functions.identity(), spMapping, tpMapping, stateFilter, transFilter);
}
/**
* Copies an {@link Automaton} to a {@link MutableAutomaton} with a compatible input alphabet, but possibly heterogeneous state and
* transition properties. States and transitions will not be filtered.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param spMapping the function for obtaining state properties
* @param tpMapping the function for obtaining transition properties
* @return a mapping from old to new states
*/
public static
Mapping rawCopy(TSTraversalMethod method,
TransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function spMapping,
Function tpMapping) {
return rawCopy(method, in, limit, inputs, out, spMapping, tpMapping, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and state and transition
* properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping the transformation for input symbols
* @param spTransform the transformation for state properties
* @param tpTransform the transformation for transition properties
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spTransform,
Function tpTransform,
Predicate stateFilter,
TransitionPredicate transFilter) {
Function spMapping = (spTransform == null) ? null : Functions.compose(spTransform, TS.stateProperties(in));
Function tpMapping = (tpTransform == null) ? null : Functions.compose(tpTransform, TS.transitionProperties(in));
return rawCopy(method, in, limit, inputs, out, inputsMapping, spMapping, tpMapping, stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and state and transition
* properties. States and transitions will not be filtered
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping the transformation for input symbols
* @param spTransform the transformation for state properties
* @param tpTransform the transformation for transition properties
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spTransform,
Function tpTransform) {
return copy(method, in, limit, inputs, out, inputsMapping, spTransform, tpTransform, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with compatible input alphabets, but possibly heterogeneous
* properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param spTransform the transformation for state properties
* @param tpTransform the transformation for transition properties
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function spTransform,
Function tpTransform,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, limit, inputs, out, Functions.identity(), spTransform, tpTransform, stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with compatible input alphabets, but possibly heterogeneous
* properties. States and transitions will not be filtered.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param spTransform the transformation for state properties
* @param tpTransform the transformation for transition properties
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function spTransform,
Function tpTransform) {
return copy(method, in, limit, inputs, out, spTransform, tpTransform, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
/**
* Copies a {@link UniversalAutomaton} with possibly heterogeneous input alphabets, but compatible properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping the transformation for input symbols
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, limit, inputs, out, inputsMapping, Functions.identity(), Functions.identity(), stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} with possibly heterogeneous input alphabets, but compatible properties. States and
* transitions will not be filtered
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param inputsMapping a mapping from inputs in the input automaton to inputs in the output automaton
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Function inputsMapping) {
return copy(method, in, limit, inputs, out, inputsMapping, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
/**
* Copies a {@link UniversalAutomaton} with compatible input alphabets and properties.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @param stateFilter the filter predicate for states
* @param transFilter the filter predicate for transitions
* @return a mapping from old to new states
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, limit, inputs, out, Functions.identity(), stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} with compatible input alphabets and properties. States and transitions
* will not be filtered.
*
* @param method the traversal method to use
* @param in the input transition system
* @param limit the traversal limit, a value less than 0 means no limit
* @param inputs the inputs to consider
* @param out the output automaton
* @return a mapping from old to new states.
*/
public static
Mapping copy(TSTraversalMethod method,
UniversalTransitionSystem in,
int limit,
Collection inputs,
MutableAutomaton out) {
return copy(method, in, limit, inputs, out, Predicates.alwaysTrue(), TransitionPredicates.alwaysTrue());
}
private TSCopy() {
throw new IllegalStateException("Constructor should never be invoked");
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy