net.automatalib.util.automata.copy.AutomatonLowLevelCopy 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) 2013-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.automata.copy;
import java.util.Collection;
import java.util.function.Function;
import java.util.function.Predicate;
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.util.automata.predicates.TransitionPredicates;
public abstract class AutomatonLowLevelCopy {
/**
* Copies an {@link Automaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and
* state and transition properties.
*
* @param input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
Automaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spMapping,
Function tpMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
if(spMapping == null) {
spMapping = s -> null;
}
if(tpMapping == null) {
tpMapping = t -> null;
}
if(stateFilter == null) {
stateFilter = s -> true;
}
if(transFilter == null) {
transFilter = TransitionPredicates.alwaysTrue();
}
LowLevelAutomatonCopier copier
= method.createLowLevelCopier(in, inputs, out, inputsMapping, spMapping, tpMapping, stateFilter, transFilter);
copier.doCopy();
return copier.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 input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
Automaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spMapping,
Function tpMapping) {
return rawCopy(method, in, inputs, out, inputsMapping, spMapping, tpMapping, s -> true, (s,i,t) -> true);
}
/**
* Copies an {@link Automaton} to a {@link MutableAutomaton} with a compatible input alphabet, but possibly heterogeneous state and
* transition properties.
*
* @param input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param output automaton state type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
Automaton in,
Collection inputs,
MutableAutomaton out,
Function spMapping,
Function tpMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
return rawCopy(method, in, inputs, out, i -> i, 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 input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param output automaton state type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
Automaton in,
Collection inputs,
MutableAutomaton out,
Function spMapping,
Function tpMapping) {
return rawCopy(method, in, inputs, out, spMapping, tpMapping, s -> true, (s,i,t)->true);
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and state and transition
* properties.
*
* @param input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param input automaton state property type
* @param input automaton transition property type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spTransform,
Function tpTransform,
Predicate stateFilter,
TransitionPredicate transFilter) {
Function spMapping = (spTransform == null) ? null : s -> spTransform.apply(in.getStateProperty(s));
Function tpMapping = (tpTransform == null) ? null : t -> tpTransform.apply(in.getTransitionProperty(t));
return rawCopy(method, in, 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 input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param input automaton state property type
* @param input automaton transition property type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Function spTransform,
Function tpTransform) {
return copy(method, in, inputs, out, inputsMapping, spTransform, tpTransform, s -> true, (s,i,t) -> true);
}
/**
* Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with compatible input alphabets, but possibly heterogeneous
* properties.
*
* @param input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param input automaton state property type
* @param input automaton transition property type
* @param output automaton state type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function spTransform,
Function tpTransform,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, inputs, out, i -> i, 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 input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param input automaton state property type
* @param input automaton transition property type
* @param output automaton state type
* @param output automaton transition type
* @param output automaton state property type
* @param output automaton transition property type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function spTransform,
Function tpTransform) {
return copy(method, in, inputs, out, spTransform, tpTransform, s -> true, (s,i,t) -> true);
}
/**
* Copies a {@link UniversalAutomaton} with possibly heterogeneous input alphabets, but compatible properties.
*
*
* @param input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param state property type
* @param transition property type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, inputs, out, inputsMapping, sp -> sp, tp -> tp, stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} with possibly heterogeneous input alphabets, but compatible properties. States and
* transitions will not be filtered
*
* @param input automaton state type
* @param input automaton input symbol type
* @param input automaton transition type
* @param state property type
* @param transition property type
* @param output automaton state type
* @param output automaton input symbol type
* @param output automaton transition type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Function inputsMapping) {
return copy(method, in, inputs, out, inputsMapping, s -> true, (s,i,t) -> true);
}
/**
* Copies a {@link UniversalAutomaton} with compatible input alphabets and properties.
*
* @param input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param state property type
* @param transition property type
* @param output automaton state type
* @param output automaton transition type
*
* @param method the copy method to use
* @param in the input automaton
* @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(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out,
Predicate stateFilter,
TransitionPredicate transFilter) {
return copy(method, in, inputs, out, i -> i, stateFilter, transFilter);
}
/**
* Copies a {@link UniversalAutomaton} with compatible input alphabets and properties. States and transitions
* will not be filtered.
*
* @param input automaton state type
* @param input symbol type
* @param input automaton transition type
* @param state property type
* @param transition property type
* @param output automaton state type
* @param output automaton transition type
*
* @param method the copy method to use
* @param in the input automaton
* @param inputs the inputs to consider
* @param out the output automaton
* @return a mapping from old to new states.
*/
public static
Mapping copy(AutomatonCopyMethod method,
UniversalAutomaton in,
Collection inputs,
MutableAutomaton out) {
Predicate stateFilter = s -> true;
return copy(method, in, inputs, out, stateFilter, (s,i,t) -> true);
}
// // Guava compatibility -- do not use any more, if possible
// /**
// * Copies an {@link Automaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and
// * state and transition properties.
// *
// * @param input automaton state type
// * @param input automaton input symbol type
// * @param input automaton transition type
// * @param output automaton state type
// * @param output automaton input symbol type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping rawCopy(AutomatonCopyMethod method,
// Automaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function inputsMapping,
// com.google.common.base.Function spMapping,
// com.google.common.base.Function tpMapping,
// com.google.common.base.Predicate stateFilter,
// TransitionPredicate transFilter) {
// Function spMapping_ = (spMapping == null) ? (s -> null) : (s -> spMapping.apply(s));
// Function tpMapping_ = (tpMapping == null) ? (t -> null) : (t -> tpMapping.apply(t));
// Predicate stateFilter_ = (stateFilter == null) ? (s -> true) : (s -> stateFilter.apply(s));
// if(transFilter == null) {
// transFilter = (s,i,t) -> true;
// }
//
// LowLevelAutomatonCopier copier
// = method.createLowLevelCopier(in, inputs, out, i -> inputsMapping.apply(i), spMapping_, tpMapping_, stateFilter_, transFilter);
// copier.doCopy();
// return copier.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 input automaton state type
// * @param input automaton input symbol type
// * @param input automaton transition type
// * @param output automaton state type
// * @param output automaton input symbol type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping rawCopy(AutomatonCopyMethod method,
// Automaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function inputsMapping,
// com.google.common.base.Function spMapping,
// com.google.common.base.Function tpMapping) {
// return rawCopy(method, in, 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 input automaton state type
// * @param input symbol type
// * @param input automaton transition type
// * @param output automaton state type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping rawCopy(AutomatonCopyMethod method,
// Automaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function spMapping,
// com.google.common.base.Function tpMapping,
// com.google.common.base.Predicate stateFilter,
// TransitionPredicate transFilter) {
// return rawCopy(method, in, 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 input automaton state type
// * @param input symbol type
// * @param input automaton transition type
// * @param output automaton state type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// *
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping rawCopy(AutomatonCopyMethod method,
// Automaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function spMapping,
// com.google.common.base.Function tpMapping) {
// return rawCopy(method, in, 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 input automaton state type
// * @param input automaton input symbol type
// * @param input automaton transition type
// * @param input automaton state property type
// * @param input automaton transition property type
// * @param output automaton state type
// * @param output automaton input symbol type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// *
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping copy(AutomatonCopyMethod method,
// UniversalAutomaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function inputsMapping,
// com.google.common.base.Function spTransform,
// com.google.common.base.Function tpTransform,
// com.google.common.base.Predicate stateFilter,
// TransitionPredicate transFilter) {
// com.google.common.base.Function spMapping = (spTransform == null) ? null : Functions.compose(spTransform, TS.stateProperties(in));
// com.google.common.base.Function tpMapping = (tpTransform == null) ? null : Functions.compose(tpTransform, TS.transitionProperties(in));
// return rawCopy(method, in, 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 input automaton state type
// * @param input automaton input symbol type
// * @param input automaton transition type
// * @param input automaton state property type
// * @param input automaton transition property type
// * @param output automaton state type
// * @param output automaton input symbol type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// *
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping copy(AutomatonCopyMethod method,
// UniversalAutomaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function inputsMapping,
// com.google.common.base.Function spTransform,
// com.google.common.base.Function tpTransform) {
// return copy(method, in, 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 input automaton state type
// * @param input symbol type
// * @param input automaton transition type
// * @param input automaton state property type
// * @param input automaton transition property type
// * @param output automaton state type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// *
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping copy(AutomatonCopyMethod method,
// UniversalAutomaton in,
// Collection inputs,
// MutableAutomaton out,
// com.google.common.base.Function spTransform,
// com.google.common.base.Function tpTransform,
// com.google.common.base.Predicate stateFilter,
// TransitionPredicate transFilter) {
// return copy(method, in, 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 input automaton state type
// * @param input symbol type
// * @param input automaton transition type
// * @param input automaton state property type
// * @param input automaton transition property type
// * @param output automaton state type
// * @param output automaton transition type
// * @param output automaton state property type
// * @param output automaton transition property type
// *
// * @param method the copy method to use
// * @param in the input automaton
// * @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
// */
// @Deprecated
// public static
// Mapping copy(AutomatonCopyMethod method,
// UniversalAutomaton in,
// Collection inputs,
// MutableAutomaton